@burdenoff/be-sdk 2026.510.79

package/dist/chunk-JVBTNSPG.js

@@ -0,0 +1,1551 @@
+import { RBACModule } from './chunk-J26YGR2U.js';
+import { NotificationsModule, NotificationType } from './chunk-XC2YD6CF.js';
+import { ValidationError, QuotaExceededError, PermissionDeniedError } from './chunk-SAG6ZYWQ.js';
+import { logger } from './chunk-CBZNP6RF.js';
+import { __name } from './chunk-XE4OXN2W.js';
+
+// src/activity/index.ts
+var ActivityType = /* @__PURE__ */ (function(ActivityType2) {
+  ActivityType2["CREATE"] = "create";
+  ActivityType2["READ"] = "read";
+  ActivityType2["UPDATE"] = "update";
+  ActivityType2["DELETE"] = "delete";
+  ActivityType2["LOGIN"] = "login";
+  ActivityType2["LOGOUT"] = "logout";
+  ActivityType2["EXPORT"] = "export";
+  ActivityType2["IMPORT"] = "import";
+  ActivityType2["SHARE"] = "share";
+  ActivityType2["DOWNLOAD"] = "download";
+  ActivityType2["UPLOAD"] = "upload";
+  ActivityType2["EXECUTE"] = "execute";
+  ActivityType2["APPROVE"] = "approve";
+  ActivityType2["REJECT"] = "reject";
+  ActivityType2["CUSTOM"] = "custom";
+  return ActivityType2;
+})({});
+var ActivityStatus = /* @__PURE__ */ (function(ActivityStatus2) {
+  ActivityStatus2["SUCCESS"] = "success";
+  ActivityStatus2["FAILURE"] = "failure";
+  ActivityStatus2["PENDING"] = "pending";
+  ActivityStatus2["WARNING"] = "warning";
+  return ActivityStatus2;
+})({});
+var ActivitySeverity = /* @__PURE__ */ (function(ActivitySeverity2) {
+  ActivitySeverity2["LOW"] = "low";
+  ActivitySeverity2["MEDIUM"] = "medium";
+  ActivitySeverity2["HIGH"] = "high";
+  ActivitySeverity2["CRITICAL"] = "critical";
+  return ActivitySeverity2;
+})({});
+var ActivityModule = class {
+  static {
+    __name(this, "ActivityModule");
+  }
+  client;
+  context;
+  constructor(client, context) {
+    this.client = client;
+    this.context = context;
+  }
+  /**
+  * Log activity
+  */
+  async log(options) {
+    if (!options.userId) {
+      throw new ValidationError("User ID is required");
+    }
+    if (!options.activityType) {
+      throw new ValidationError("Activity type is required");
+    }
+    if (!options.resourceType) {
+      throw new ValidationError("Resource type is required");
+    }
+    if (!options.action) {
+      throw new ValidationError("Action is required");
+    }
+    if (!options.status) {
+      throw new ValidationError("Status is required");
+    }
+    logger.debug("[Activity] Logging activity", {
+      userId: options.userId,
+      action: options.action,
+      resourceType: options.resourceType
+    });
+    const recordActivityMutation = `
+      mutation RecordActivity($input: RecordActivityInput!) {
+        recordActivity(input: $input) {
+          id
+          userId
+          activityType
+          resourceType
+          resourceId
+          action
+          status
+          workspaceId
+          organizationId
+          projectId
+          ipAddress
+          userAgent
+          metadata
+          severity
+          errorMessage
+          duration
+          createdAt
+        }
+      }
+    `;
+    const legacyLogActivityMutation = `
+      mutation LogActivity($input: LogActivityInput!) {
+        logActivity(input: $input) {
+          id
+          userId
+          activityType
+          resourceType
+          resourceId
+          action
+          status
+          workspaceId
+          organizationId
+          projectId
+          ipAddress
+          userAgent
+          metadata
+          severity
+          errorMessage
+          duration
+          createdAt
+        }
+      }
+    `;
+    const variables = {
+      input: {
+        userId: options.userId,
+        activityType: options.activityType,
+        resourceType: options.resourceType,
+        resourceId: options.resourceId,
+        action: options.action,
+        status: options.status,
+        workspaceId: options.workspaceId,
+        organizationId: options.organizationId,
+        projectId: options.projectId,
+        ipAddress: options.ipAddress,
+        userAgent: options.userAgent,
+        metadata: options.metadata,
+        severity: options.severity || "low",
+        errorMessage: options.errorMessage,
+        duration: options.duration
+      }
+    };
+    try {
+      const response = await this.client.query(recordActivityMutation, variables, this.context);
+      logger.info("[Activity] Activity logged", {
+        activityId: response.recordActivity.id
+      });
+      return response.recordActivity;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const isRecordActivityUnavailable = message.includes('Cannot query field "recordActivity"') || message.includes('Unknown type "RecordActivityInput"');
+      if (!isRecordActivityUnavailable) {
+        throw error;
+      }
+      logger.warn("[Activity] Falling back to legacy logActivity mutation", {
+        reason: message
+      });
+      const legacyResponse = await this.client.query(legacyLogActivityMutation, variables, this.context);
+      logger.info("[Activity] Activity logged (legacy)", {
+        activityId: legacyResponse.logActivity.id
+      });
+      return legacyResponse.logActivity;
+    }
+  }
+  /**
+  * Log activity with automatic status detection
+  */
+  async logSuccess(userId, action, resourceType, resourceId, metadata) {
+    return this.log({
+      userId,
+      action,
+      resourceType,
+      resourceId,
+      activityType: this.inferActivityType(action),
+      status: "success",
+      severity: "low",
+      metadata,
+      workspaceId: this.context.workspaceId
+    });
+  }
+  /**
+  * Log failed activity
+  */
+  async logFailure(userId, action, resourceType, errorMessage, resourceId, metadata) {
+    return this.log({
+      userId,
+      action,
+      resourceType,
+      resourceId,
+      activityType: this.inferActivityType(action),
+      status: "failure",
+      severity: "high",
+      errorMessage,
+      metadata,
+      workspaceId: this.context.workspaceId
+    });
+  }
+  /**
+  * Get activities with filters
+  */
+  async getActivities(options) {
+    logger.debug("[Activity] Getting activities", options);
+    const query = `
+      query GetActivities(
+        $userId: ID
+        $workspaceId: ID
+        $organizationId: ID
+        $projectId: ID
+        $activityType: ActivityType
+        $resourceType: String
+        $resourceId: ID
+        $status: ActivityStatus
+        $severity: ActivitySeverity
+        $startDate: DateTime
+        $endDate: DateTime
+        $search: String
+        $limit: Int
+        $offset: Int
+        $sortBy: String
+        $sortOrder: String
+      ) {
+        getActivities(
+          userId: $userId
+          workspaceId: $workspaceId
+          organizationId: $organizationId
+          projectId: $projectId
+          activityType: $activityType
+          resourceType: $resourceType
+          resourceId: $resourceId
+          status: $status
+          severity: $severity
+          startDate: $startDate
+          endDate: $endDate
+          search: $search
+          limit: $limit
+          offset: $offset
+          sortBy: $sortBy
+          sortOrder: $sortOrder
+        ) {
+          activities {
+            id
+            userId
+            activityType
+            resourceType
+            resourceId
+            action
+            status
+            workspaceId
+            organizationId
+            projectId
+            ipAddress
+            userAgent
+            metadata
+            severity
+            errorMessage
+            duration
+            createdAt
+          }
+          total
+        }
+      }
+    `;
+    const variables = {
+      userId: options.userId,
+      workspaceId: options.workspaceId,
+      organizationId: options.organizationId,
+      projectId: options.projectId,
+      activityType: options.activityType,
+      resourceType: options.resourceType,
+      resourceId: options.resourceId,
+      status: options.status,
+      severity: options.severity,
+      startDate: options.startDate,
+      endDate: options.endDate,
+      search: options.search,
+      limit: options.limit || 50,
+      offset: options.offset || 0,
+      sortBy: options.sortBy || "createdAt",
+      sortOrder: options.sortOrder || "desc"
+    };
+    const response = await this.client.query(query, variables, this.context);
+    return response.getActivities;
+  }
+  /**
+  * Get activity by ID
+  */
+  async getActivity(activityId) {
+    logger.debug("[Activity] Getting activity", {
+      activityId
+    });
+    const query = `
+      query GetActivity($activityId: ID!) {
+        getActivity(activityId: $activityId) {
+          id
+          userId
+          activityType
+          resourceType
+          resourceId
+          action
+          status
+          workspaceId
+          organizationId
+          projectId
+          ipAddress
+          userAgent
+          metadata
+          severity
+          errorMessage
+          duration
+          createdAt
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      activityId
+    }, this.context);
+    return response.getActivity;
+  }
+  /**
+  * Get activity statistics
+  */
+  async getStats(options) {
+    logger.debug("[Activity] Getting activity stats", options);
+    const query = `
+      query GetActivityStats(
+        $userId: ID
+        $workspaceId: ID
+        $organizationId: ID
+        $projectId: ID
+        $activityType: ActivityType
+        $resourceType: String
+        $startDate: DateTime
+        $endDate: DateTime
+      ) {
+        getActivityStats(
+          userId: $userId
+          workspaceId: $workspaceId
+          organizationId: $organizationId
+          projectId: $projectId
+          activityType: $activityType
+          resourceType: $resourceType
+          startDate: $startDate
+          endDate: $endDate
+        ) {
+          totalActivities
+          successCount
+          failureCount
+          pendingCount
+          warningCount
+          averageDuration
+          activitiesByType
+          activitiesBySeverity
+          topUsers {
+            userId
+            count
+          }
+          topResources {
+            resourceType
+            count
+          }
+        }
+      }
+    `;
+    const variables = {
+      userId: options.userId,
+      workspaceId: options.workspaceId,
+      organizationId: options.organizationId,
+      projectId: options.projectId,
+      activityType: options.activityType,
+      resourceType: options.resourceType,
+      startDate: options.startDate,
+      endDate: options.endDate
+    };
+    const response = await this.client.query(query, variables, this.context);
+    return response.getActivityStats;
+  }
+  /**
+  * Delete old activities (cleanup)
+  */
+  async cleanup(olderThanDays, workspaceId) {
+    logger.debug("[Activity] Cleaning up old activities", {
+      olderThanDays,
+      workspaceId
+    });
+    const mutation = `
+      mutation CleanupActivities($olderThanDays: Int!, $workspaceId: ID) {
+        cleanupActivities(olderThanDays: $olderThanDays, workspaceId: $workspaceId) {
+          deletedCount
+        }
+      }
+    `;
+    const response = await this.client.query(mutation, {
+      olderThanDays,
+      workspaceId
+    }, this.context);
+    logger.info("[Activity] Cleanup completed", {
+      deletedCount: response.cleanupActivities.deletedCount
+    });
+    return response.cleanupActivities.deletedCount;
+  }
+  /**
+  * Infer activity type from action string
+  */
+  inferActivityType(action) {
+    const actionLower = action.toLowerCase();
+    if (actionLower.includes("create") || actionLower.includes("add")) {
+      return "create";
+    }
+    if (actionLower.includes("update") || actionLower.includes("edit") || actionLower.includes("modify")) {
+      return "update";
+    }
+    if (actionLower.includes("delete") || actionLower.includes("remove")) {
+      return "delete";
+    }
+    if (actionLower.includes("read") || actionLower.includes("view") || actionLower.includes("get")) {
+      return "read";
+    }
+    if (actionLower.includes("login") || actionLower.includes("signin")) {
+      return "login";
+    }
+    if (actionLower.includes("logout") || actionLower.includes("signout")) {
+      return "logout";
+    }
+    if (actionLower.includes("export")) {
+      return "export";
+    }
+    if (actionLower.includes("import")) {
+      return "import";
+    }
+    if (actionLower.includes("share")) {
+      return "share";
+    }
+    if (actionLower.includes("download")) {
+      return "download";
+    }
+    if (actionLower.includes("upload")) {
+      return "upload";
+    }
+    if (actionLower.includes("execute") || actionLower.includes("run")) {
+      return "execute";
+    }
+    if (actionLower.includes("approve")) {
+      return "approve";
+    }
+    if (actionLower.includes("reject")) {
+      return "reject";
+    }
+    return "custom";
+  }
+  /**
+  * Export activities to CSV
+  */
+  async exportToCSV(options) {
+    logger.debug("[Activity] Exporting activities to CSV");
+    const query = `
+      query ExportActivities(
+        $userId: ID
+        $workspaceId: ID
+        $organizationId: ID
+        $startDate: DateTime
+        $endDate: DateTime
+      ) {
+        exportActivities(
+          userId: $userId
+          workspaceId: $workspaceId
+          organizationId: $organizationId
+          startDate: $startDate
+          endDate: $endDate
+        ) {
+          csvData
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      userId: options.userId,
+      workspaceId: options.workspaceId,
+      organizationId: options.organizationId,
+      startDate: options.startDate,
+      endDate: options.endDate
+    }, this.context);
+    logger.info("[Activity] Activities exported to CSV");
+    return response.exportActivities.csvData;
+  }
+};
+
+// src/usage/index.ts
+var UsageMetricType = /* @__PURE__ */ (function(UsageMetricType2) {
+  UsageMetricType2["API_CALLS"] = "api_calls";
+  UsageMetricType2["STORAGE"] = "storage";
+  UsageMetricType2["BANDWIDTH"] = "bandwidth";
+  UsageMetricType2["USERS"] = "users";
+  UsageMetricType2["PROJECTS"] = "projects";
+  UsageMetricType2["WORKSPACES"] = "workspaces";
+  UsageMetricType2["RECORDS"] = "records";
+  UsageMetricType2["COMPUTE_TIME"] = "compute_time";
+  UsageMetricType2["TRANSACTIONS"] = "transactions";
+  UsageMetricType2["CUSTOM"] = "custom";
+  return UsageMetricType2;
+})({});
+var UsageModule = class {
+  static {
+    __name(this, "UsageModule");
+  }
+  client;
+  context;
+  constructor(client, context) {
+    this.client = client;
+    this.context = context;
+  }
+  /**
+  * Track usage
+  */
+  async track(options) {
+    if (!options.entityId) {
+      throw new ValidationError("Entity ID is required");
+    }
+    if (!options.entityType) {
+      throw new ValidationError("Entity type is required");
+    }
+    if (!options.metricType) {
+      throw new ValidationError("Metric type is required");
+    }
+    if (typeof options.amount !== "number" || options.amount <= 0) {
+      throw new ValidationError("Amount must be a positive number");
+    }
+    logger.debug("[Usage] Tracking usage", {
+      entityId: options.entityId,
+      metricType: options.metricType,
+      amount: options.amount
+    });
+    const mutation = `
+      mutation TrackUsage($input: TrackUsageInput!) {
+        trackUsage(input: $input) {
+          id
+          entityId
+          entityType
+          metricType
+          amount
+          resourceId
+          metadata
+          workspaceId
+          organizationId
+          recordedAt
+        }
+      }
+    `;
+    const variables = {
+      input: {
+        entityId: options.entityId,
+        entityType: options.entityType,
+        metricType: options.metricType,
+        amount: options.amount,
+        resourceId: options.resourceId,
+        metadata: options.metadata,
+        workspaceId: options.workspaceId || this.context.workspaceId,
+        organizationId: options.organizationId
+      }
+    };
+    const response = await this.client.query(mutation, variables, this.context);
+    logger.info("[Usage] Usage tracked", {
+      recordId: response.trackUsage.id
+    });
+    return response.trackUsage;
+  }
+  /**
+  * Check quota availability
+  */
+  async checkQuota(options) {
+    if (!options.entityId) {
+      throw new ValidationError("Entity ID is required");
+    }
+    if (!options.metricType) {
+      throw new ValidationError("Metric type is required");
+    }
+    if (typeof options.requestedAmount !== "number" || options.requestedAmount <= 0) {
+      throw new ValidationError("Requested amount must be a positive number");
+    }
+    logger.debug("[Usage] Checking quota", {
+      entityId: options.entityId,
+      metricType: options.metricType,
+      requestedAmount: options.requestedAmount
+    });
+    const query = `
+      query CheckQuota($input: CheckQuotaInput!) {
+        checkQuota(input: $input) {
+          allowed
+          currentUsage
+          quotaLimit
+          remainingQuota
+          resetAt
+          period
+          reason
+        }
+      }
+    `;
+    const variables = {
+      input: {
+        entityId: options.entityId,
+        entityType: options.entityType,
+        metricType: options.metricType,
+        requestedAmount: options.requestedAmount,
+        workspaceId: options.workspaceId || this.context.workspaceId,
+        organizationId: options.organizationId
+      }
+    };
+    const response = await this.client.query(query, variables, this.context);
+    logger.debug("[Usage] Quota check result", {
+      allowed: response.checkQuota.allowed
+    });
+    return response.checkQuota;
+  }
+  /**
+  * Require quota (throws if exceeded)
+  */
+  async requireQuota(options) {
+    const result = await this.checkQuota(options);
+    if (!result.allowed) {
+      throw new QuotaExceededError(result.reason || "Quota exceeded", {
+        entityId: options.entityId,
+        metricType: options.metricType,
+        currentUsage: result.currentUsage,
+        quotaLimit: result.quotaLimit,
+        requestedAmount: options.requestedAmount,
+        resetAt: result.resetAt
+      });
+    }
+  }
+  /**
+  * Track usage and check quota atomically
+  */
+  async trackAndCheck(options) {
+    const quotaCheck = await this.checkQuota({
+      entityId: options.entityId,
+      entityType: options.entityType,
+      metricType: options.metricType,
+      requestedAmount: options.amount,
+      workspaceId: options.workspaceId,
+      organizationId: options.organizationId
+    });
+    if (!quotaCheck.allowed) {
+      throw new QuotaExceededError(quotaCheck.reason || "Quota exceeded", {
+        entityId: options.entityId,
+        metricType: options.metricType,
+        currentUsage: quotaCheck.currentUsage,
+        quotaLimit: quotaCheck.quotaLimit
+      });
+    }
+    const usage = await this.track(options);
+    return {
+      usage,
+      quotaCheck
+    };
+  }
+  /**
+  * Get usage records
+  */
+  async getUsage(options) {
+    logger.debug("[Usage] Getting usage records", {
+      entityId: options.entityId
+    });
+    const query = `
+      query GetUsage(
+        $entityId: ID!
+        $entityType: String!
+        $metricType: UsageMetricType
+        $startDate: DateTime
+        $endDate: DateTime
+        $workspaceId: ID
+        $organizationId: ID
+        $limit: Int
+        $offset: Int
+      ) {
+        getUsage(
+          entityId: $entityId
+          entityType: $entityType
+          metricType: $metricType
+          startDate: $startDate
+          endDate: $endDate
+          workspaceId: $workspaceId
+          organizationId: $organizationId
+          limit: $limit
+          offset: $offset
+        ) {
+          records {
+            id
+            entityId
+            entityType
+            metricType
+            amount
+            resourceId
+            metadata
+            workspaceId
+            organizationId
+            recordedAt
+          }
+          total
+        }
+      }
+    `;
+    const variables = {
+      entityId: options.entityId,
+      entityType: options.entityType,
+      metricType: options.metricType,
+      startDate: options.startDate,
+      endDate: options.endDate,
+      workspaceId: options.workspaceId || this.context.workspaceId,
+      organizationId: options.organizationId,
+      limit: options.limit || 100,
+      offset: options.offset || 0
+    };
+    const response = await this.client.query(query, variables, this.context);
+    return response.getUsage;
+  }
+  /**
+  * Get usage summary
+  */
+  async getSummary(entityId, entityType, metricType, period) {
+    logger.debug("[Usage] Getting usage summary", {
+      entityId,
+      metricType,
+      period
+    });
+    const query = `
+      query GetUsageSummary(
+        $entityId: ID!
+        $entityType: String!
+        $metricType: UsageMetricType!
+        $period: QuotaPeriod!
+      ) {
+        getUsageSummary(
+          entityId: $entityId
+          entityType: $entityType
+          metricType: $metricType
+          period: $period
+        ) {
+          entityId
+          entityType
+          metricType
+          totalUsage
+          period
+          periodStart
+          periodEnd
+          quotaLimit
+          utilizationPercentage
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      entityId,
+      entityType,
+      metricType,
+      period
+    }, this.context);
+    return response.getUsageSummary;
+  }
+  /**
+  * Set quota limit
+  */
+  async setQuota(options) {
+    if (!options.entityId) {
+      throw new ValidationError("Entity ID is required");
+    }
+    if (!options.metricType) {
+      throw new ValidationError("Metric type is required");
+    }
+    if (typeof options.limit !== "number" || options.limit < 0) {
+      throw new ValidationError("Limit must be a non-negative number");
+    }
+    logger.debug("[Usage] Setting quota", {
+      entityId: options.entityId,
+      metricType: options.metricType,
+      limit: options.limit
+    });
+    const mutation = `
+      mutation SetQuota($input: SetQuotaInput!) {
+        setQuota(input: $input) {
+          id
+          entityId
+          entityType
+          metricType
+          limit
+          period
+          currentUsage
+          resetAt
+          createdAt
+          updatedAt
+        }
+      }
+    `;
+    const variables = {
+      input: {
+        entityId: options.entityId,
+        entityType: options.entityType,
+        metricType: options.metricType,
+        limit: options.limit,
+        period: options.period,
+        workspaceId: options.workspaceId || this.context.workspaceId,
+        organizationId: options.organizationId
+      }
+    };
+    const response = await this.client.query(mutation, variables, this.context);
+    logger.info("[Usage] Quota set", {
+      quotaId: response.setQuota.id
+    });
+    return response.setQuota;
+  }
+  /**
+  * Get quota
+  */
+  async getQuota(entityId, entityType, metricType) {
+    logger.debug("[Usage] Getting quota", {
+      entityId,
+      metricType
+    });
+    const query = `
+      query GetQuota($entityId: ID!, $entityType: String!, $metricType: UsageMetricType!) {
+        getQuota(entityId: $entityId, entityType: $entityType, metricType: $metricType) {
+          id
+          entityId
+          entityType
+          metricType
+          limit
+          period
+          currentUsage
+          resetAt
+          createdAt
+          updatedAt
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      entityId,
+      entityType,
+      metricType
+    }, this.context);
+    return response.getQuota;
+  }
+  /**
+  * Get all quotas for entity
+  */
+  async getQuotas(entityId, entityType) {
+    logger.debug("[Usage] Getting all quotas", {
+      entityId,
+      entityType
+    });
+    const query = `
+      query GetQuotas($entityId: ID!, $entityType: String!) {
+        getQuotas(entityId: $entityId, entityType: $entityType) {
+          id
+          entityId
+          entityType
+          metricType
+          limit
+          period
+          currentUsage
+          resetAt
+          createdAt
+          updatedAt
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      entityId,
+      entityType
+    }, this.context);
+    return response.getQuotas;
+  }
+  /**
+  * Reset quota usage
+  */
+  async resetQuota(entityId, entityType, metricType) {
+    logger.debug("[Usage] Resetting quota", {
+      entityId,
+      metricType
+    });
+    const mutation = `
+      mutation ResetQuota($entityId: ID!, $entityType: String!, $metricType: UsageMetricType!) {
+        resetQuota(entityId: $entityId, entityType: $entityType, metricType: $metricType) {
+          success
+        }
+      }
+    `;
+    await this.client.query(mutation, {
+      entityId,
+      entityType,
+      metricType
+    }, this.context);
+    logger.info("[Usage] Quota reset", {
+      entityId,
+      metricType
+    });
+    return true;
+  }
+  /**
+  * Delete quota
+  */
+  async deleteQuota(entityId, entityType, metricType) {
+    logger.debug("[Usage] Deleting quota", {
+      entityId,
+      metricType
+    });
+    const mutation = `
+      mutation DeleteQuota($entityId: ID!, $entityType: String!, $metricType: UsageMetricType!) {
+        deleteQuota(entityId: $entityId, entityType: $entityType, metricType: $metricType) {
+          success
+        }
+      }
+    `;
+    await this.client.query(mutation, {
+      entityId,
+      entityType,
+      metricType
+    }, this.context);
+    logger.info("[Usage] Quota deleted", {
+      entityId,
+      metricType
+    });
+    return true;
+  }
+  /**
+  * Bulk track usage
+  */
+  async trackBulk(records) {
+    logger.debug("[Usage] Bulk tracking usage", {
+      count: records.length
+    });
+    const mutation = `
+      mutation TrackUsageBulk($records: [TrackUsageInput!]!) {
+        trackUsageBulk(records: $records) {
+          id
+          entityId
+          entityType
+          metricType
+          amount
+          resourceId
+          metadata
+          workspaceId
+          organizationId
+          recordedAt
+        }
+      }
+    `;
+    const response = await this.client.query(mutation, {
+      records
+    }, this.context);
+    logger.info("[Usage] Bulk usage tracked", {
+      count: response.trackUsageBulk.length
+    });
+    return response.trackUsageBulk;
+  }
+};
+
+// src/tracker/stub.ts
+var _gatewayUrl;
+var _gatewayUrlResolved = false;
+function getGatewayUrl() {
+  if (!_gatewayUrlResolved) {
+    _gatewayUrl = process.env["WSPACE_INT_GATEWAY_URL"] ?? process.env["GLOBAL_INT_GATEWAY_URL"] ?? void 0;
+    _gatewayUrlResolved = true;
+    if (_gatewayUrl) {
+      logger.info(`[trackOperation] Real tracking enabled via gateway: ${_gatewayUrl}`);
+    } else {
+      logger.debug("[trackOperation] No gateway URL configured \u2014 running in stub mode");
+    }
+  }
+  return _gatewayUrl;
+}
+__name(getGatewayUrl, "getGatewayUrl");
+var LOG_ACTIVITY_MUTATION = (
+  /* GraphQL */
+  `
+  mutation RecordActivity($input: RecordActivityInput!) {
+    recordActivity(input: $input) {
+      id
+    }
+  }
+`
+);
+async function fireActivityLog(gatewayUrl, options) {
+  try {
+    const actOpts = options.activityOptions;
+    const input = {
+      activityType: actOpts?.activityType ?? options.operationName ?? "unknown",
+      description: actOpts?.description ?? `${options.operationName ?? "operation"} executed`,
+      workspaceId: actOpts?.workspaceId ?? options.workspaceId,
+      resourceType: actOpts?.resourceType ?? options.resourceType,
+      resourceId: actOpts?.resourceId ?? options.resourceId,
+      metadata: {
+        ...actOpts?.metadata,
+        userId: options.userId,
+        success: options.success ?? true,
+        ...options.errorMessage ? {
+          errorMessage: options.errorMessage
+        } : {}
+      }
+    };
+    for (const key of Object.keys(input)) {
+      if (input[key] === void 0) delete input[key];
+    }
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (options.userId) {
+      headers["x-actor-id"] = options.userId;
+      headers["x-actor-type"] = "service";
+    }
+    if (options.workspaceId ?? actOpts?.workspaceId) {
+      headers["x-workspace-id"] = options.workspaceId ?? actOpts?.workspaceId;
+    }
+    const response = await fetch(gatewayUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        query: LOG_ACTIVITY_MUTATION,
+        variables: {
+          input
+        }
+      }),
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!response.ok) {
+      logger.warn(`[trackOperation] Activity log HTTP ${response.status}: ${options.operationName}`);
+    }
+  } catch (err) {
+    logger.warn(`[trackOperation] Activity log failed: ${err.message}`);
+  }
+}
+__name(fireActivityLog, "fireActivityLog");
+var UnifiedTrackerStub = class _UnifiedTrackerStub {
+  static {
+    __name(this, "UnifiedTrackerStub");
+  }
+  static instance;
+  static getInstance() {
+    if (!_UnifiedTrackerStub.instance) {
+      _UnifiedTrackerStub.instance = new _UnifiedTrackerStub();
+    }
+    return _UnifiedTrackerStub.instance;
+  }
+  async track(event) {
+    const gatewayUrl = getGatewayUrl();
+    if (gatewayUrl) {
+      await fireActivityLog(gatewayUrl, {
+        operationName: event.eventType,
+        userId: event.userId,
+        workspaceId: event.workspaceId,
+        resourceType: event.entityType,
+        resourceId: event.entityId,
+        activityOptions: {
+          activityType: event.eventType,
+          metadata: event.metadata,
+          workspaceId: event.workspaceId,
+          resourceType: event.entityType,
+          resourceId: event.entityId,
+          enabled: true
+        }
+      });
+    } else {
+      logger.debug("[UnifiedTracker:Stub]", event.eventType, event.entityType, event.entityId);
+    }
+  }
+  async trackBatch(events) {
+    for (const event of events) {
+      await this.track(event);
+    }
+  }
+};
+var trackerStub = UnifiedTrackerStub.getInstance();
+async function trackOperation(options) {
+  const { operationName, userId, success = true } = options;
+  const gatewayUrl = getGatewayUrl();
+  if (!gatewayUrl) {
+    logger.debug(`[trackOperation:Stub] ${operationName} for user ${userId} - success: ${success}`);
+    return true;
+  }
+  const activityEnabled = options.activityOptions?.enabled !== false;
+  if (activityEnabled) {
+    void fireActivityLog(gatewayUrl, options);
+  } else {
+    logger.debug(`[trackOperation] ${operationName} for user ${userId} - activity disabled, skipping`);
+  }
+  return true;
+}
+__name(trackOperation, "trackOperation");
+function createProductTracker(productId, userId, billingAccountId, defaultContext) {
+  return {
+    async track(operationName, additionalOptions) {
+      return trackOperation({
+        ...defaultContext,
+        productId,
+        operationName,
+        userId,
+        ...additionalOptions
+      });
+    },
+    async freeUp(operationName, additionalOptions) {
+      return trackOperation({
+        ...defaultContext,
+        productId,
+        operationName,
+        userId,
+        ...additionalOptions,
+        activityOptions: {
+          ...defaultContext?.activityOptions,
+          ...additionalOptions?.activityOptions,
+          activityType: "free_up"
+        }
+      });
+    },
+    async trackActivityOnly(operationName, additionalOptions) {
+      return trackOperation({
+        ...defaultContext,
+        productId,
+        operationName,
+        userId,
+        ...additionalOptions,
+        activityOptions: {
+          ...defaultContext?.activityOptions,
+          ...additionalOptions?.activityOptions,
+          enabled: true
+        },
+        usageOptions: {
+          enabled: false
+        }
+      });
+    },
+    async trackUsageOnly(operationName, additionalOptions) {
+      return trackOperation({
+        ...defaultContext,
+        productId,
+        operationName,
+        userId,
+        ...additionalOptions,
+        activityOptions: {
+          enabled: false
+        },
+        usageOptions: {
+          ...defaultContext?.usageOptions,
+          ...additionalOptions?.usageOptions,
+          enabled: true
+        }
+      });
+    },
+    async trackCustom(operationName, additionalOptions) {
+      return trackOperation({
+        ...defaultContext,
+        productId,
+        operationName,
+        userId,
+        ...additionalOptions
+      });
+    },
+    productId,
+    userId,
+    billingAccountId,
+    defaultContext
+  };
+}
+__name(createProductTracker, "createProductTracker");
+var UNIFIED_TRACKER_CONSTANTS = {
+  DEFAULT_PRODUCT_ID: "module",
+  OPERATIONS: {},
+  PRODUCTS: {}
+};
+
+// src/tracker/index.ts
+var TrackerModule = class {
+  static {
+    __name(this, "TrackerModule");
+  }
+  context;
+  rbac;
+  activity;
+  usage;
+  notifications;
+  constructor(client, context = {}) {
+    this.context = context;
+    this.rbac = new RBACModule(client, context);
+    this.activity = new ActivityModule(client, context);
+    this.usage = new UsageModule(client, context);
+    this.notifications = new NotificationsModule(client, context);
+  }
+  /**
+  * Track operation with RBAC, Activity, Usage, and Notifications
+  * This is the primary method products should use
+  */
+  async track(options) {
+    const startTime = Date.now();
+    const result = {
+      success: false,
+      permissionGranted: false,
+      duration: 0
+    };
+    try {
+      this.validateOptions(options);
+      if (options.rbac?.enabled !== false) {
+        await this.checkPermission(options, result);
+        if (!result.permissionGranted) {
+          result.duration = Date.now() - startTime;
+          await this.logFailedActivity(options, result, startTime);
+          return result;
+        }
+      } else {
+        result.permissionGranted = true;
+      }
+      if (options.usage?.enabled !== false && options.usage?.checkQuota !== false) {
+        await this.checkQuota(options, result);
+        if (result.quotaAvailable === false) {
+          result.duration = Date.now() - startTime;
+          await this.logFailedActivity(options, result, startTime);
+          return result;
+        }
+      }
+      if (options.usage?.enabled !== false && options.usage?.metricType) {
+        await this.trackUsage(options, result);
+      }
+      if (options.activity?.enabled !== false) {
+        await this.logSuccessActivity(options, result, startTime);
+      }
+      if (options.notification?.onSuccess) {
+        await this.sendSuccessNotification(options, result);
+      }
+      result.success = true;
+      result.duration = Date.now() - startTime;
+      logger.info("[Tracker] Operation tracked successfully", {
+        action: options.action,
+        duration: result.duration
+      });
+      return result;
+    } catch (error) {
+      result.duration = Date.now() - startTime;
+      result.success = false;
+      if (error instanceof PermissionDeniedError) {
+        result.error = {
+          type: "permission",
+          message: error.message,
+          details: error.details
+        };
+      } else if (error instanceof QuotaExceededError) {
+        result.error = {
+          type: "quota",
+          message: error.message,
+          details: error.details
+        };
+      } else if (error instanceof ValidationError) {
+        result.error = {
+          type: "validation",
+          message: error.message,
+          details: error.details
+        };
+      } else {
+        result.error = {
+          type: "unknown",
+          message: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+      await this.logFailedActivity(options, result, startTime);
+      if (options.notification?.onFailure) {
+        await this.sendFailureNotification(options, result);
+      }
+      logger.error("[Tracker] Operation tracking failed", {
+        action: options.action,
+        error: result.error,
+        duration: result.duration
+      });
+      return result;
+    }
+  }
+  /**
+  * Track operation and throw on failure
+  * Convenience method that throws errors instead of returning them in result
+  */
+  async trackOrThrow(options) {
+    const result = await this.track(options);
+    if (!result.success && result.error) {
+      const errorMessage = result.error.message;
+      const errorDetails = result.error.details;
+      switch (result.error.type) {
+        case "permission":
+          throw new PermissionDeniedError(errorMessage, errorDetails);
+        case "quota":
+          throw new QuotaExceededError(errorMessage, errorDetails);
+        case "validation":
+          throw new ValidationError(errorMessage, errorDetails);
+        default:
+          throw new Error(errorMessage);
+      }
+    }
+    return result;
+  }
+  /**
+  * Simplified track method for common operations
+  */
+  async trackSimple(userId, action, resourceType, resourceId, metricType) {
+    const result = await this.track({
+      userId,
+      action,
+      resourceType,
+      resourceId,
+      workspaceId: this.context.workspaceId,
+      usage: metricType ? {
+        enabled: true,
+        metricType,
+        amount: 1,
+        checkQuota: true
+      } : {
+        enabled: false,
+        metricType: "api_calls"
+      }
+    });
+    return result.success;
+  }
+  /**
+  * Validate tracking options
+  */
+  validateOptions(options) {
+    if (!options.userId) {
+      throw new ValidationError("User ID is required");
+    }
+    if (!options.action) {
+      throw new ValidationError("Action is required");
+    }
+    if (!options.resourceType) {
+      throw new ValidationError("Resource type is required");
+    }
+  }
+  /**
+  * Check RBAC permission
+  */
+  async checkPermission(options, result) {
+    const permissionOptions = {
+      userId: options.userId,
+      action: options.rbac?.permissionAction || options.action,
+      resourceType: options.resourceType,
+      resourceId: options.resourceId,
+      workspaceId: options.workspaceId
+    };
+    const hasPermission = await this.rbac.checkPermission(permissionOptions);
+    result.permissionGranted = hasPermission;
+    if (!hasPermission) {
+      result.error = {
+        type: "permission",
+        message: "Permission denied",
+        details: permissionOptions
+      };
+    }
+  }
+  /**
+  * Check quota availability
+  */
+  async checkQuota(options, result) {
+    if (!options.usage?.metricType) {
+      return;
+    }
+    const entityType = options.usage.entityType || "user";
+    let entityId;
+    if (entityType === "workspace") {
+      entityId = options.workspaceId || options.userId;
+    } else if (entityType === "organization") {
+      entityId = options.organizationId || options.userId;
+    } else {
+      entityId = options.userId;
+    }
+    const quotaCheck = await this.usage.checkQuota({
+      entityId,
+      entityType,
+      metricType: options.usage.metricType,
+      requestedAmount: options.usage.amount || 1,
+      workspaceId: options.workspaceId,
+      organizationId: options.organizationId
+    });
+    result.quotaAvailable = quotaCheck.allowed;
+    result.quotaRemaining = quotaCheck.remainingQuota;
+    if (!quotaCheck.allowed) {
+      result.error = {
+        type: "quota",
+        message: quotaCheck.reason || "Quota exceeded",
+        details: {
+          currentUsage: quotaCheck.currentUsage,
+          quotaLimit: quotaCheck.quotaLimit,
+          requestedAmount: options.usage.amount || 1
+        }
+      };
+    }
+  }
+  /**
+  * Track usage
+  */
+  async trackUsage(options, result) {
+    if (!options.usage?.metricType) {
+      return;
+    }
+    const entityType = options.usage.entityType || "user";
+    let entityId;
+    if (entityType === "workspace") {
+      entityId = options.workspaceId || options.userId;
+    } else if (entityType === "organization") {
+      entityId = options.organizationId || options.userId;
+    } else {
+      entityId = options.userId;
+    }
+    const trackOptions = {
+      entityId,
+      entityType,
+      metricType: options.usage.metricType,
+      amount: options.usage.amount || 1,
+      resourceId: options.resourceId,
+      workspaceId: options.workspaceId,
+      organizationId: options.organizationId
+    };
+    const usageRecord = await this.usage.track(trackOptions);
+    result.usageRecordId = usageRecord.id;
+  }
+  /**
+  * Log successful activity
+  */
+  async logSuccessActivity(options, result, startTime) {
+    const activityRecord = await this.activity.log({
+      userId: options.userId,
+      activityType: options.activity?.activityType || this.inferActivityType(options.action),
+      resourceType: options.resourceType,
+      resourceId: options.resourceId,
+      action: options.action,
+      status: ActivityStatus.SUCCESS,
+      workspaceId: options.workspaceId,
+      organizationId: options.organizationId,
+      projectId: options.projectId,
+      ipAddress: options.activity?.ipAddress,
+      userAgent: options.activity?.userAgent,
+      metadata: options.activity?.metadata,
+      severity: options.activity?.severity || ActivitySeverity.LOW,
+      duration: Date.now() - startTime
+    });
+    result.activityId = activityRecord.id;
+  }
+  /**
+  * Log failed activity
+  */
+  async logFailedActivity(options, result, startTime) {
+    if (options.activity?.enabled === false) {
+      return;
+    }
+    try {
+      const activityRecord = await this.activity.log({
+        userId: options.userId,
+        activityType: options.activity?.activityType || this.inferActivityType(options.action),
+        resourceType: options.resourceType,
+        resourceId: options.resourceId,
+        action: options.action,
+        status: ActivityStatus.FAILURE,
+        workspaceId: options.workspaceId,
+        organizationId: options.organizationId,
+        projectId: options.projectId,
+        ipAddress: options.activity?.ipAddress,
+        userAgent: options.activity?.userAgent,
+        metadata: options.activity?.metadata,
+        severity: ActivitySeverity.HIGH,
+        errorMessage: result.error?.message,
+        duration: Date.now() - startTime
+      });
+      result.activityId = activityRecord.id;
+    } catch (error) {
+      logger.error("[Tracker] Failed to log activity", {
+        error
+      });
+    }
+  }
+  /**
+  * Send success notification
+  */
+  async sendSuccessNotification(options, result) {
+    if (!options.notification?.onSuccess) {
+      return;
+    }
+    try {
+      const userIds = [
+        options.userId,
+        ...options.notification.onSuccess.additionalUserIds || []
+      ];
+      const response = await this.notifications.send({
+        title: options.notification.onSuccess.title,
+        message: options.notification.onSuccess.message,
+        type: options.notification.onSuccess.type || NotificationType.SUCCESS,
+        userIds
+      });
+      result.notificationIds = response.notificationIds;
+    } catch (error) {
+      logger.error("[Tracker] Failed to send success notification", {
+        error
+      });
+    }
+  }
+  /**
+  * Send failure notification
+  */
+  async sendFailureNotification(options, result) {
+    if (!options.notification?.onFailure) {
+      return;
+    }
+    try {
+      const userIds = [
+        options.userId,
+        ...options.notification.onFailure.additionalUserIds || []
+      ];
+      const response = await this.notifications.send({
+        title: options.notification.onFailure.title,
+        message: options.notification.onFailure.message,
+        type: options.notification.onFailure.type || NotificationType.ERROR,
+        userIds
+      });
+      result.notificationIds = response.notificationIds;
+    } catch (error) {
+      logger.error("[Tracker] Failed to send failure notification", {
+        error
+      });
+    }
+  }
+  /**
+  * Infer activity type from action
+  */
+  inferActivityType(action) {
+    const actionLower = action.toLowerCase();
+    if (actionLower.includes("create") || actionLower.includes("add")) return ActivityType.CREATE;
+    if (actionLower.includes("update") || actionLower.includes("edit")) return ActivityType.UPDATE;
+    if (actionLower.includes("delete") || actionLower.includes("remove")) return ActivityType.DELETE;
+    if (actionLower.includes("read") || actionLower.includes("view")) return ActivityType.READ;
+    if (actionLower.includes("login")) return ActivityType.LOGIN;
+    if (actionLower.includes("logout")) return ActivityType.LOGOUT;
+    if (actionLower.includes("export")) return ActivityType.EXPORT;
+    if (actionLower.includes("import")) return ActivityType.IMPORT;
+    if (actionLower.includes("share")) return ActivityType.SHARE;
+    if (actionLower.includes("download")) return ActivityType.DOWNLOAD;
+    if (actionLower.includes("upload")) return ActivityType.UPLOAD;
+    return ActivityType.CUSTOM;
+  }
+  /**
+  * Batch track multiple operations
+  */
+  async trackBatch(operations) {
+    logger.debug("[Tracker] Batch tracking operations", {
+      count: operations.length
+    });
+    const results = await Promise.all(operations.map((op) => this.track(op)));
+    logger.info("[Tracker] Batch tracking completed", {
+      total: results.length,
+      successful: results.filter((r) => r.success).length,
+      failed: results.filter((r) => !r.success).length
+    });
+    return results;
+  }
+};
+
+export { ActivityModule, TrackerModule, UNIFIED_TRACKER_CONSTANTS, UnifiedTrackerStub, UsageMetricType, UsageModule, createProductTracker, trackOperation, trackerStub };
+//# sourceMappingURL=chunk-JVBTNSPG.js.map
+//# sourceMappingURL=chunk-JVBTNSPG.js.map