@burdenoff/be-sdk 2026.510.79

package/dist/index.js

@@ -0,0 +1,2626 @@
+export { TemporalClient, TemporalClientFactory, TemporalModule, TemporalWorker, TemporalWorkerFactory, TemporalWorkerManager } from './chunk-Z4IRLBWO.js';
+export { instrumentation_exports as Instrumentation } from './chunk-4XAEES25.js';
+export { middleware_exports as Middleware } from './chunk-2HANKZZM.js';
+export { observability_exports as Observability } from './chunk-5LXDPGDH.js';
+export { prisma_exports as Prisma } from './chunk-2SD5L2F2.js';
+import './chunk-GTEMQXCA.js';
+import { ActivityModule, UsageModule, TrackerModule } from './chunk-JVBTNSPG.js';
+export { ActivityModule, TrackerModule, UsageModule } from './chunk-JVBTNSPG.js';
+import { RBACModule } from './chunk-J26YGR2U.js';
+export { RBACModule, createRBACDirective, createRBACDirectiveForLayer, createRBACDirectiveFromEnv } from './chunk-J26YGR2U.js';
+import { TenantNotificationsModule, NotificationsModule } from './chunk-XC2YD6CF.js';
+export { tenant_notifications_exports as Notifications, NotificationsModule } from './chunk-XC2YD6CF.js';
+export { crypto_exports as Crypto } from './chunk-SBS4S2PJ.js';
+export { createInternalClient, createInternalClientForTenant, createInternalClientForWorkspaces } from './chunk-VI4VSNTI.js';
+export { feature_flags_exports as FeatureFlags } from './chunk-VWCN5PMD.js';
+import { GraphModule } from './chunk-F5XEAGHQ.js';
+export { graph_exports as Graph, GraphModule } from './chunk-F5XEAGHQ.js';
+import './chunk-TKBD2ONF.js';
+export { graphql_exports as GraphQL } from './chunk-MNCGUYLJ.js';
+import './chunk-QLVKMWFA.js';
+export { i18n_exports as I18n, createTranslator, getLanguage, getLocale, hasI18n, t } from './chunk-IYE2NTRX.js';
+export { init_exports as Init } from './chunk-AI7L22ZJ.js';
+import { AuthModule } from './chunk-SAK2JCA7.js';
+export { AuthModule } from './chunk-SAK2JCA7.js';
+export { utils_exports as Utils } from './chunk-MOCUBSTW.js';
+export { cache_exports as Cache } from './chunk-4XGGWW36.js';
+export { captcha_exports as Captcha, isCaptchaEnabled, verifyCaptcha, verifyCaptchaIfEnabled } from './chunk-YMZEUTD2.js';
+export { export_exports as Export } from './chunk-FNZEQOJY.js';
+export { gateway_exports as Gateway } from './chunk-4B43DZIS.js';
+import './chunk-MLW2HPS5.js';
+export { layer_exports as Layer } from './chunk-HIWTWIGQ.js';
+import { EventsModule } from './chunk-M5IMU3US.js';
+export { event_queue_exports as EventQueue, EventsModule } from './chunk-M5IMU3US.js';
+import './chunk-ELLX3K54.js';
+import { EventQueueFactory } from './chunk-3O2RQOPV.js';
+import './chunk-L7ZMN2FJ.js';
+import './chunk-OVSYMNCI.js';
+export { dataloader_exports as DataLoader } from './chunk-NUB5GQTU.js';
+import { DatabaseModule } from './chunk-JG2FTZPI.js';
+export { DatabaseModule } from './chunk-JG2FTZPI.js';
+import { APIError, NetworkError, TimeoutError, ValidationError } from './chunk-SAG6ZYWQ.js';
+export { DEFAULT_CIRCUIT_BREAKER_CONFIG, DEFAULT_GATEWAY_RETRY_CONFIG, DEFAULT_GATEWAY_ROUTING, DEFAULT_LAYER_RESOURCES, DEFAULT_LAYER_STREAMS } from './chunk-NGMEI42S.js';
+import { logger } from './chunk-CBZNP6RF.js';
+export { logger_exports as Logger } from './chunk-CBZNP6RF.js';
+import { __name } from './chunk-XE4OXN2W.js';
+import { GraphQLClient } from 'graphql-request';
+import { AsyncLocalStorage } from 'async_hooks';
+
+var BurdenoffGraphQLClient = class {
+  static {
+    __name(this, "BurdenoffGraphQLClient");
+  }
+  workspacesClient;
+  tenantClient;
+  config;
+  defaultContext;
+  constructor(config, defaultContext = {}) {
+    this.config = config;
+    this.defaultContext = defaultContext;
+    this.workspacesClient = new GraphQLClient(config.workspacesApiUrl, {
+      headers: this.getHeaders(defaultContext)
+    });
+    if (config.tenantApiUrl) {
+      this.tenantClient = new GraphQLClient(config.tenantApiUrl, {
+        headers: this.getHeaders(defaultContext)
+      });
+    }
+  }
+  /**
+  * Get headers for GraphQL request
+  * Includes actor context headers for RBAC authorization
+  */
+  getHeaders(context) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (context.token) {
+      headers["Authorization"] = `Bearer ${context.token}`;
+    }
+    if (context.actorId) {
+      headers["x-actor-id"] = context.actorId;
+    }
+    if (context.actorType) {
+      headers["x-actor-type"] = context.actorType;
+    }
+    if (context.workspaceId) {
+      headers["x-workspace-id"] = context.workspaceId;
+    }
+    if (context.productId) {
+      headers["x-product-id"] = context.productId;
+    }
+    return headers;
+  }
+  /**
+  * Update context for future requests
+  */
+  updateContext(context) {
+    this.defaultContext = {
+      ...this.defaultContext,
+      ...context
+    };
+    this.workspacesClient.setHeaders(this.getHeaders(this.defaultContext));
+    if (this.tenantClient) {
+      this.tenantClient.setHeaders(this.getHeaders(this.defaultContext));
+    }
+  }
+  /**
+  * Execute GraphQL query/mutation against workspaces API
+  */
+  async query(query, variables, context) {
+    return this.executeWithRetry(() => this.executeQuery(this.workspacesClient, query, variables, context), "workspaces");
+  }
+  /**
+  * Execute GraphQL query/mutation against tenant API
+  */
+  async tenantQuery(query, variables, context) {
+    if (!this.tenantClient) {
+      throw new APIError("Tenant API URL not configured", {
+        operation: "tenantQuery"
+      });
+    }
+    return this.executeWithRetry(() => this.executeQuery(this.tenantClient, query, variables, context), "tenant");
+  }
+  /**
+  * Execute GraphQL request
+  */
+  async executeQuery(client, query, variables, context) {
+    try {
+      const mergedContext = {
+        ...this.defaultContext,
+        ...context
+      };
+      if (context) {
+        const headers = this.getHeaders(mergedContext);
+        client.setHeaders(headers);
+      }
+      const response = await client.request(query, variables);
+      return response;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+  /**
+  * Execute with retry logic
+  */
+  async executeWithRetry(operation, api) {
+    const maxAttempts = this.config.retry?.maxAttempts || 3;
+    const initialDelay = this.config.retry?.initialDelay || 1e3;
+    const maxDelay = this.config.retry?.maxDelay || 1e4;
+    const backoffMultiplier = this.config.retry?.backoffMultiplier || 2;
+    let lastError;
+    let delay = initialDelay;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+        if (error instanceof APIError && !this.shouldRetry(error)) {
+          throw error;
+        }
+        if (attempt === maxAttempts) {
+          break;
+        }
+        await this.sleep(Math.min(delay, maxDelay));
+        delay *= backoffMultiplier;
+      }
+    }
+    throw new APIError(`GraphQL request failed after ${maxAttempts} attempts`, {
+      api,
+      lastError: lastError?.message
+    });
+  }
+  /**
+  * Determine if error should be retried
+  */
+  shouldRetry(error) {
+    if (error instanceof NetworkError || error instanceof TimeoutError) {
+      return true;
+    }
+    if (error.code === "SERVER_ERROR") {
+      return true;
+    }
+    return false;
+  }
+  /**
+  * Handle GraphQL errors
+  */
+  handleError(error) {
+    if (error instanceof Error) {
+      if (error.message.includes("fetch failed") || error.message.includes("ECONNREFUSED")) {
+        return new NetworkError("Network error while connecting to API", {
+          originalError: error.message
+        });
+      }
+      if (error.message.includes("timeout") || error.message.includes("ETIMEDOUT")) {
+        return new TimeoutError("Request timed out", {
+          originalError: error.message
+        });
+      }
+      if ("response" in error && error.response) {
+        const response = error.response;
+        if (response.errors && response.errors.length > 0) {
+          const firstError = response.errors[0];
+          if (firstError) {
+            return new APIError(firstError.message, {
+              graphqlErrors: response.errors,
+              extensions: firstError.extensions
+            });
+          }
+        }
+      }
+      return new APIError(error.message, {
+        originalError: error.message
+      });
+    }
+    return new APIError("Unknown error occurred", {
+      error: String(error)
+    });
+  }
+  /**
+  * Sleep utility for retry delays
+  */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+  * Get current context
+  */
+  getContext() {
+    return {
+      ...this.defaultContext
+    };
+  }
+};
+var asyncLocalStorage = new AsyncLocalStorage();
+var ContextManager = class {
+  static {
+    __name(this, "ContextManager");
+  }
+  /**
+  * Get current context from async local storage
+  */
+  static getContext() {
+    return asyncLocalStorage.getStore();
+  }
+  /**
+  * Set context for current async scope
+  * Merges with existing context if present
+  */
+  static setContext(context) {
+    const currentContext = this.getContext() || {};
+    asyncLocalStorage.enterWith({
+      ...currentContext,
+      ...context
+    });
+  }
+  /**
+  * Run function with specific context
+  * Context is isolated to this execution and its children
+  */
+  static async withContext(context, fn) {
+    return asyncLocalStorage.run(context, fn);
+  }
+  /**
+  * Run synchronous function with specific context
+  */
+  static withContextSync(context, fn) {
+    return asyncLocalStorage.run(context, fn);
+  }
+  /**
+  * Clear current context
+  */
+  static clearContext() {
+    asyncLocalStorage.disable();
+  }
+  /**
+  * Get actor ID from context
+  */
+  static getActorId() {
+    return this.getContext()?.actorId;
+  }
+  /**
+  * Get legacy user ID from context.
+  */
+  static getUser() {
+    const context = this.getContext();
+    const userId = context?.["userId"];
+    return typeof userId === "string" ? userId : context?.actorId;
+  }
+  /**
+  * Get workspace ID from context
+  */
+  static getWorkspace() {
+    return this.getContext()?.workspaceId;
+  }
+  /**
+  * Get tenant ID from context
+  */
+  static getTenant() {
+    return this.getContext()?.tenantId;
+  }
+  /**
+  * Get legacy organization ID from context.
+  */
+  static getOrganization() {
+    const organizationId = this.getContext()?.["organizationId"];
+    return typeof organizationId === "string" ? organizationId : void 0;
+  }
+  /**
+  * Get project ID from context
+  */
+  static getProject() {
+    return this.getContext()?.projectId;
+  }
+  /**
+  * Get app ID from context
+  */
+  static getApp() {
+    return this.getContext()?.appId;
+  }
+  /**
+  * Get JWT token from context
+  */
+  static getToken() {
+    return this.getContext()?.token;
+  }
+  /**
+  * Get product ID from context
+  */
+  static getProduct() {
+    return this.getContext()?.productId;
+  }
+  /**
+  * Update specific context fields
+  */
+  static updateContext(updates) {
+    const current = this.getContext();
+    if (current) {
+      this.setContext({
+        ...current,
+        ...updates
+      });
+    } else {
+      this.setContext(updates);
+    }
+  }
+  /**
+  * Check if context exists
+  */
+  static hasContext() {
+    return this.getContext() !== void 0;
+  }
+  /**
+  * Get custom field from context
+  */
+  static getCustomField(key) {
+    return this.getContext()?.[key];
+  }
+  /**
+  * Set custom field in context
+  */
+  static setCustomField(key, value) {
+    const current = this.getContext() || {};
+    this.setContext({
+      ...current,
+      [key]: value
+    });
+  }
+};
+
+// src/search/index.ts
+var SearchModule = class {
+  static {
+    __name(this, "SearchModule");
+  }
+  client;
+  context;
+  constructor(client, context) {
+    this.client = client;
+    this.context = context;
+  }
+  /**
+  * Search across all resources
+  */
+  async search(options) {
+    if (!options.query || options.query.trim().length === 0) {
+      throw new ValidationError("Search query is required");
+    }
+    logger.debug("[Search] Searching", {
+      query: options.query,
+      resourceTypes: options.resourceTypes
+    });
+    const query = `
+      query Search($input: SearchInput!) {
+        search(input: $input) {
+          results {
+            id
+            type
+            title
+            description
+            data
+            workspaceId
+            organizationId
+            projectId
+            score
+            highlights
+            createdAt
+            updatedAt
+          }
+          total
+          took
+          aggregations
+        }
+      }
+    `;
+    const variables = {
+      input: {
+        query: options.query,
+        resourceTypes: options.resourceTypes,
+        workspaceId: options.workspaceId || this.context.workspaceId,
+        organizationId: options.organizationId,
+        projectId: options.projectId || this.context.projectId,
+        fields: options.fields,
+        fuzziness: options.fuzziness || 0.8,
+        boosts: options.boosts,
+        filters: options.filters,
+        sort: options.sort,
+        limit: options.limit || 20,
+        offset: options.offset || 0,
+        highlight: options.highlight !== false
+      }
+    };
+    const response = await this.client.query(query, variables, this.context);
+    logger.info("[Search] Search completed", {
+      total: response.search.total,
+      took: response.search.took
+    });
+    return response.search;
+  }
+  /**
+  * Index document for search
+  */
+  async indexDocument(options) {
+    if (!options.id) {
+      throw new ValidationError("Document ID is required");
+    }
+    if (!options.type) {
+      throw new ValidationError("Document type is required");
+    }
+    if (!options.title) {
+      throw new ValidationError("Document title is required");
+    }
+    logger.debug("[Search] Indexing document", {
+      id: options.id,
+      type: options.type
+    });
+    const mutation = `
+      mutation IndexDocument($input: IndexDocumentInput!) {
+        indexDocument(input: $input) {
+          id
+          indexed
+        }
+      }
+    `;
+    const variables = {
+      input: {
+        id: options.id,
+        type: options.type,
+        title: options.title,
+        description: options.description,
+        content: options.content,
+        data: options.data,
+        workspaceId: options.workspaceId || this.context.workspaceId,
+        organizationId: options.organizationId,
+        projectId: options.projectId || this.context.projectId,
+        tags: options.tags,
+        metadata: options.metadata
+      }
+    };
+    const response = await this.client.query(mutation, variables, this.context);
+    logger.info("[Search] Document indexed", {
+      id: response.indexDocument.id
+    });
+    return response.indexDocument;
+  }
+  /**
+  * Remove document from search index
+  */
+  async removeDocument(id, type) {
+    logger.debug("[Search] Removing document", {
+      id,
+      type
+    });
+    const mutation = `
+      mutation RemoveDocument($id: ID!, $type: String!) {
+        removeDocument(id: $id, type: $type) {
+          success
+        }
+      }
+    `;
+    await this.client.query(mutation, {
+      id,
+      type
+    }, this.context);
+    logger.info("[Search] Document removed", {
+      id
+    });
+    return true;
+  }
+  /**
+  * Update document in search index
+  */
+  async updateDocument(id, type, updates) {
+    logger.debug("[Search] Updating document", {
+      id,
+      type
+    });
+    const mutation = `
+      mutation UpdateDocument($id: ID!, $type: String!, $updates: JSON!) {
+        updateDocument(id: $id, type: $type, updates: $updates) {
+          id
+          updated
+        }
+      }
+    `;
+    const response = await this.client.query(mutation, {
+      id,
+      type,
+      updates
+    }, this.context);
+    logger.info("[Search] Document updated", {
+      id
+    });
+    return response.updateDocument;
+  }
+  /**
+  * Bulk index documents
+  */
+  async indexDocumentsBulk(documents) {
+    logger.debug("[Search] Bulk indexing documents", {
+      count: documents.length
+    });
+    const mutation = `
+      mutation IndexDocumentsBulk($documents: [IndexDocumentInput!]!) {
+        indexDocumentsBulk(documents: $documents) {
+          indexed
+          failed
+          errors
+        }
+      }
+    `;
+    const response = await this.client.query(mutation, {
+      documents
+    }, this.context);
+    logger.info("[Search] Bulk indexing completed", {
+      indexed: response.indexDocumentsBulk.indexed,
+      failed: response.indexDocumentsBulk.failed
+    });
+    return response.indexDocumentsBulk;
+  }
+  /**
+  * Get search suggestions (autocomplete)
+  */
+  async suggest(prefix, options) {
+    if (!prefix || prefix.trim().length === 0) {
+      throw new ValidationError("Prefix is required for suggestions");
+    }
+    logger.debug("[Search] Getting suggestions", {
+      prefix
+    });
+    const query = `
+      query GetSuggestions($prefix: String!, $resourceTypes: [String!], $limit: Int) {
+        getSuggestions(prefix: $prefix, resourceTypes: $resourceTypes, limit: $limit) {
+          text
+          score
+          type
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      prefix,
+      resourceTypes: options?.resourceTypes,
+      limit: options?.limit || 10
+    }, this.context);
+    return response.getSuggestions;
+  }
+  /**
+  * Get related documents
+  */
+  async getRelated(documentId, options) {
+    logger.debug("[Search] Getting related documents", {
+      documentId
+    });
+    const query = `
+      query GetRelatedDocuments($documentId: ID!, $limit: Int, $minScore: Float) {
+        getRelatedDocuments(documentId: $documentId, limit: $limit, minScore: $minScore) {
+          id
+          type
+          title
+          description
+          data
+          score
+          createdAt
+          updatedAt
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      documentId,
+      limit: options?.limit || 10,
+      minScore: options?.minScore || 0.5
+    }, this.context);
+    return response.getRelatedDocuments;
+  }
+  /**
+  * Get search aggregations
+  */
+  async aggregate(query, aggregations) {
+    logger.debug("[Search] Getting aggregations", {
+      query
+    });
+    const gqlQuery = `
+      query GetAggregations($query: String!, $aggregations: [AggregationInput!]!) {
+        getAggregations(query: $query, aggregations: $aggregations) {
+          aggregations
+        }
+      }
+    `;
+    const response = await this.client.query(gqlQuery, {
+      query,
+      aggregations
+    }, this.context);
+    return response.getAggregations.aggregations;
+  }
+  /**
+  * Clear search index for workspace
+  */
+  async clearIndex(workspaceId) {
+    logger.debug("[Search] Clearing index", {
+      workspaceId
+    });
+    const mutation = `
+      mutation ClearSearchIndex($workspaceId: ID) {
+        clearSearchIndex(workspaceId: $workspaceId) {
+          deletedCount
+        }
+      }
+    `;
+    const response = await this.client.query(mutation, {
+      workspaceId: workspaceId || this.context.workspaceId
+    }, this.context);
+    logger.info("[Search] Index cleared", {
+      deletedCount: response.clearSearchIndex.deletedCount
+    });
+    return response.clearSearchIndex;
+  }
+  /**
+  * Reindex all documents
+  */
+  async reindex(options) {
+    logger.debug("[Search] Reindexing", options);
+    const mutation = `
+      mutation ReindexDocuments($workspaceId: ID, $resourceTypes: [String!]) {
+        reindexDocuments(workspaceId: $workspaceId, resourceTypes: $resourceTypes) {
+          indexed
+          failed
+        }
+      }
+    `;
+    const response = await this.client.query(mutation, {
+      workspaceId: options?.workspaceId || this.context.workspaceId,
+      resourceTypes: options?.resourceTypes
+    }, this.context);
+    logger.info("[Search] Reindexing completed", response.reindexDocuments);
+    return response.reindexDocuments;
+  }
+};
+
+// src/translation/index.ts
+var TranslationModule = class {
+  static {
+    __name(this, "TranslationModule");
+  }
+  client;
+  context;
+  constructor(client, context) {
+    this.client = client;
+    this.context = context;
+  }
+  /**
+  * Translate text
+  */
+  async translate(options) {
+    if (!options.text || options.text.trim().length === 0) {
+      throw new ValidationError("Text to translate is required");
+    }
+    if (!options.targetLanguage) {
+      throw new ValidationError("Target language is required");
+    }
+    logger.debug("[Translation] Translating text", {
+      sourceLanguage: options.sourceLanguage || "auto",
+      targetLanguage: options.targetLanguage,
+      textLength: options.text.length
+    });
+    const query = `
+      query Translate($input: TranslateInput!) {
+        translate(input: $input) {
+          original
+          translated
+          sourceLanguage
+          targetLanguage
+          confidence
+        }
+      }
+    `;
+    const variables = {
+      input: {
+        text: options.text,
+        sourceLanguage: options.sourceLanguage,
+        targetLanguage: options.targetLanguage,
+        context: options.context
+      }
+    };
+    const response = await this.client.query(query, variables, this.context);
+    let translated = response.translate.translated;
+    if (options.variables) {
+      translated = this.interpolate(translated, options.variables);
+    }
+    logger.info("[Translation] Text translated", {
+      sourceLanguage: response.translate.sourceLanguage,
+      targetLanguage: response.translate.targetLanguage
+    });
+    return {
+      ...response.translate,
+      translated
+    };
+  }
+  /**
+  * Get translations for keys
+  */
+  async getTranslations(options) {
+    if (!options.keys || options.keys.length === 0) {
+      throw new ValidationError("Translation keys are required");
+    }
+    if (!options.language) {
+      throw new ValidationError("Language is required");
+    }
+    logger.debug("[Translation] Getting translations", {
+      language: options.language,
+      count: options.keys.length
+    });
+    const query = `
+      query GetTranslations(
+        $keys: [String!]!
+        $language: String!
+        $namespace: String
+        $fallbackLanguage: String
+      ) {
+        getTranslations(
+          keys: $keys
+          language: $language
+          namespace: $namespace
+          fallbackLanguage: $fallbackLanguage
+        ) {
+          translations
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      keys: options.keys,
+      language: options.language,
+      namespace: options.namespace,
+      fallbackLanguage: options.fallbackLanguage || "en"
+    }, this.context);
+    return response.getTranslations.translations;
+  }
+  /**
+  * Get single translation
+  */
+  async get(key, language, variables) {
+    const translations = await this.getTranslations({
+      keys: [
+        key
+      ],
+      language
+    });
+    let translation = translations[key] || key;
+    if (variables) {
+      translation = this.interpolate(translation, variables);
+    }
+    return translation;
+  }
+  /**
+  * Set translation
+  */
+  async setTranslation(options) {
+    if (!options.key) {
+      throw new ValidationError("Translation key is required");
+    }
+    if (!options.value) {
+      throw new ValidationError("Translation value is required");
+    }
+    if (!options.language) {
+      throw new ValidationError("Language is required");
+    }
+    logger.debug("[Translation] Setting translation", {
+      key: options.key,
+      language: options.language
+    });
+    const mutation = `
+      mutation SetTranslation($input: SetTranslationInput!) {
+        setTranslation(input: $input) {
+          key
+          value
+          language
+          namespace
+          description
+          variables
+        }
+      }
+    `;
+    const variables = {
+      input: {
+        key: options.key,
+        value: options.value,
+        language: options.language,
+        namespace: options.namespace,
+        description: options.description,
+        variables: options.variables
+      }
+    };
+    const response = await this.client.query(mutation, variables, this.context);
+    logger.info("[Translation] Translation set", {
+      key: options.key,
+      language: options.language
+    });
+    return response.setTranslation;
+  }
+  /**
+  * Delete translation
+  */
+  async deleteTranslation(key, language, namespace) {
+    logger.debug("[Translation] Deleting translation", {
+      key,
+      language
+    });
+    const mutation = `
+      mutation DeleteTranslation($key: String!, $language: String!, $namespace: String) {
+        deleteTranslation(key: $key, language: $language, namespace: $namespace) {
+          success
+        }
+      }
+    `;
+    await this.client.query(mutation, {
+      key,
+      language,
+      namespace
+    }, this.context);
+    logger.info("[Translation] Translation deleted", {
+      key,
+      language
+    });
+    return true;
+  }
+  /**
+  * Batch set translations
+  */
+  async setTranslationsBatch(translations) {
+    logger.debug("[Translation] Batch setting translations", {
+      count: translations.length
+    });
+    const mutation = `
+      mutation SetTranslationsBatch($translations: [SetTranslationInput!]!) {
+        setTranslationsBatch(translations: $translations) {
+          key
+          value
+          language
+          namespace
+          description
+          variables
+        }
+      }
+    `;
+    const response = await this.client.query(mutation, {
+      translations
+    }, this.context);
+    logger.info("[Translation] Batch translations set", {
+      count: response.setTranslationsBatch.length
+    });
+    return response.setTranslationsBatch;
+  }
+  /**
+  * Get all translations for language
+  */
+  async getAllTranslations(language, namespace) {
+    logger.debug("[Translation] Getting all translations", {
+      language,
+      namespace
+    });
+    const query = `
+      query GetAllTranslations($language: String!, $namespace: String) {
+        getAllTranslations(language: $language, namespace: $namespace) {
+          key
+          value
+          language
+          namespace
+          description
+          variables
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      language,
+      namespace
+    }, this.context);
+    return response.getAllTranslations;
+  }
+  /**
+  * Detect language
+  */
+  async detectLanguage(text) {
+    if (!text || text.trim().length === 0) {
+      throw new ValidationError("Text is required for language detection");
+    }
+    logger.debug("[Translation] Detecting language");
+    const query = `
+      query DetectLanguage($text: String!) {
+        detectLanguage(text: $text) {
+          language
+          confidence
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      text
+    }, this.context);
+    return response.detectLanguage;
+  }
+  /**
+  * Get supported languages
+  */
+  async getSupportedLanguages() {
+    logger.debug("[Translation] Getting supported languages");
+    const query = `
+      query GetSupportedLanguages {
+        getSupportedLanguages {
+          code
+          name
+          nativeName
+        }
+      }
+    `;
+    const response = await this.client.query(query, {}, this.context);
+    return response.getSupportedLanguages;
+  }
+  /**
+  * Import translations from file
+  */
+  async importTranslations(language, translations, namespace) {
+    logger.debug("[Translation] Importing translations", {
+      language,
+      count: Object.keys(translations).length
+    });
+    const mutation = `
+      mutation ImportTranslations($language: String!, $translations: JSON!, $namespace: String) {
+        importTranslations(language: $language, translations: $translations, namespace: $namespace) {
+          imported
+          failed
+        }
+      }
+    `;
+    const response = await this.client.query(mutation, {
+      language,
+      translations,
+      namespace
+    }, this.context);
+    logger.info("[Translation] Translations imported", response.importTranslations);
+    return response.importTranslations;
+  }
+  /**
+  * Export translations to JSON
+  */
+  async exportTranslations(language, namespace) {
+    logger.debug("[Translation] Exporting translations", {
+      language,
+      namespace
+    });
+    const query = `
+      query ExportTranslations($language: String!, $namespace: String) {
+        exportTranslations(language: $language, namespace: $namespace) {
+          translations
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      language,
+      namespace
+    }, this.context);
+    logger.info("[Translation] Translations exported", {
+      language,
+      count: Object.keys(response.exportTranslations.translations).length
+    });
+    return response.exportTranslations.translations;
+  }
+  /**
+  * Export product translations from global i18n service (federated schema).
+  *
+  * This uses the modern i18n GraphQL contract:
+  * - i18nProductByName
+  * - exportTranslations(productId, languageCode, format)
+  */
+  async exportProductTranslations(options) {
+    const productId = await this.resolveProductId(options.productId, options.productName);
+    const languageCode = options.languageCode ?? "en";
+    const format = options.format ?? "JSON";
+    const query = `
+      query ExportProductTranslations(
+        $productId: String!
+        $languageCode: String!
+        $format: ImportJobFormat!
+      ) {
+        exportTranslations(productId: $productId, languageCode: $languageCode, format: $format) {
+          format
+          url
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      productId,
+      languageCode,
+      format
+    }, this.context);
+    const result = {
+      format: response.exportTranslations.format,
+      url: response.exportTranslations.url
+    };
+    if ((options.decodeJson ?? true) && format === "JSON") {
+      result.translations = this.decodeDataUrlJson(response.exportTranslations.url);
+    }
+    return result;
+  }
+  /**
+  * Upsert product translations in global i18n service.
+  *
+  * Behavior:
+  * - Ensures translation keys exist (create if missing)
+  * - Optionally updates translation key defaultValue
+  * - Creates/updates language translation entries
+  * - Optionally publishes translations
+  */
+  async upsertProductTranslations(options) {
+    if (!options.languageCode) {
+      throw new ValidationError("languageCode is required");
+    }
+    const flatTranslations = this.flattenTranslationTree(options.translations);
+    if (Object.keys(flatTranslations).length === 0) {
+      throw new ValidationError("translations cannot be empty");
+    }
+    const flatDefaults = options.defaultValues ? this.flattenTranslationTree(options.defaultValues) : flatTranslations;
+    const productId = await this.resolveProductId(options.productId, options.productName);
+    const publish = options.publish ?? true;
+    const updateExisting = options.updateExisting ?? true;
+    const result = {
+      productId,
+      languageCode: options.languageCode,
+      keysProcessed: 0,
+      createdKeys: 0,
+      updatedKeyDefaults: 0,
+      createdTranslations: 0,
+      updatedTranslations: 0
+    };
+    const entries = Object.entries(flatTranslations);
+    const existingKeysMap = /* @__PURE__ */ new Map();
+    for (const [key] of entries) {
+      const keyRow = await this.findTranslationKeyByKey(productId, key);
+      if (keyRow) {
+        existingKeysMap.set(key, keyRow);
+      }
+    }
+    for (const [key, value] of entries) {
+      const defaultValue = flatDefaults[key] ?? value;
+      let keyId = "";
+      const keyRow = existingKeysMap.get(key);
+      if (!keyRow) {
+        const createdKey = await this.createTranslationKey(productId, key, defaultValue);
+        keyId = createdKey.id;
+        result.createdKeys += 1;
+      } else {
+        keyId = keyRow.id;
+        if (defaultValue && keyRow.defaultValue !== defaultValue) {
+          await this.updateTranslationKeyDefaultValue(keyId, defaultValue);
+          result.updatedKeyDefaults += 1;
+        }
+      }
+      const translationRow = await this.findGlobalTranslation(keyId, options.languageCode);
+      if (!translationRow) {
+        const createdTranslation = await this.createLanguageTranslation(keyId, options.languageCode, value);
+        result.createdTranslations += 1;
+        if (publish && createdTranslation.status !== "PUBLISHED") {
+          await this.updateLanguageTranslation(createdTranslation.id, value, "PUBLISHED");
+        }
+      } else {
+        const shouldUpdateValue = updateExisting && translationRow.value !== value;
+        const shouldPublish = publish && translationRow.status !== "PUBLISHED";
+        if (shouldUpdateValue || shouldPublish) {
+          await this.updateLanguageTranslation(translationRow.id, shouldUpdateValue ? value : translationRow.value, publish ? "PUBLISHED" : translationRow.status);
+          if (shouldUpdateValue) {
+            result.updatedTranslations += 1;
+          }
+        }
+      }
+      result.keysProcessed += 1;
+    }
+    logger.info("[Translation] Product translations upsert completed", {
+      productId,
+      languageCode: options.languageCode,
+      keysProcessed: result.keysProcessed,
+      createdKeys: result.createdKeys,
+      createdTranslations: result.createdTranslations,
+      updatedTranslations: result.updatedTranslations
+    });
+    return result;
+  }
+  flattenTranslationTree(input, prefix = "") {
+    const out = {};
+    for (const [key, rawValue] of Object.entries(input)) {
+      const nextKey = prefix ? `${prefix}.${key}` : key;
+      if (typeof rawValue === "string") {
+        out[nextKey] = rawValue;
+        continue;
+      }
+      if (rawValue && typeof rawValue === "object") {
+        Object.assign(out, this.flattenTranslationTree(rawValue, nextKey));
+      }
+    }
+    return out;
+  }
+  decodeDataUrlJson(url) {
+    if (!url.startsWith("data:")) {
+      throw new ValidationError("Expected exportTranslations URL to be a data URL");
+    }
+    const commaIdx = url.indexOf(",");
+    if (commaIdx === -1) {
+      throw new ValidationError("Invalid data URL: missing comma separator");
+    }
+    const header = url.slice(0, commaIdx);
+    const payload = url.slice(commaIdx + 1);
+    if (!payload) {
+      throw new ValidationError("Invalid data URL payload");
+    }
+    try {
+      const decoded = header.includes("base64") ? Buffer.from(payload, "base64").toString("utf8") : decodeURIComponent(payload);
+      return JSON.parse(decoded);
+    } catch (error) {
+      logger.error("[Translation] Failed to decode data URL JSON", {
+        error,
+        isBase64: header.includes("base64")
+      });
+      throw new ValidationError("Failed to decode JSON translation payload");
+    }
+  }
+  async resolveProductId(productId, productName) {
+    if (productId) {
+      return productId;
+    }
+    if (!productName) {
+      throw new ValidationError("Either productId or productName is required");
+    }
+    const query = `
+      query GetI18nProductByName($name: String!) {
+        i18nProductByName(name: $name) {
+          id
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      name: productName
+    }, this.context);
+    if (!response.i18nProductByName?.id) {
+      throw new ValidationError(`i18n product not found: ${productName}`);
+    }
+    return response.i18nProductByName.id;
+  }
+  async findTranslationKeyByKey(productId, key) {
+    const query = `
+      query FindTranslationKey($productId: String!, $key: String!) {
+        translationKeyByKey(productId: $productId, key: $key) {
+          id
+          defaultValue
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      productId,
+      key
+    }, this.context);
+    return response.translationKeyByKey;
+  }
+  async createTranslationKey(productId, key, defaultValue) {
+    const mutation = `
+      mutation CreateTranslationKey($input: CreateTranslationKeyInput!) {
+        createTranslationKey(input: $input) {
+          id
+        }
+      }
+    `;
+    const response = await this.client.query(mutation, {
+      input: {
+        productId,
+        key,
+        defaultValue
+      }
+    }, this.context);
+    return response.createTranslationKey;
+  }
+  async updateTranslationKeyDefaultValue(id, defaultValue) {
+    const mutation = `
+      mutation UpdateTranslationKeyDefault($id: ID!, $input: UpdateTranslationKeyInput!) {
+        updateTranslationKey(id: $id, input: $input) {
+          id
+        }
+      }
+    `;
+    await this.client.query(mutation, {
+      id,
+      input: {
+        defaultValue
+      }
+    }, this.context);
+  }
+  async findGlobalTranslation(keyId, languageCode) {
+    const query = `
+      query FindTranslation($filter: TranslationFilterInput) {
+        translations(filter: $filter, limit: 50, offset: 0) {
+          items {
+            id
+            value
+            status
+            tenantId
+          }
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      filter: {
+        keyId,
+        languageCode
+      }
+    }, this.context);
+    const globalTranslation = response.translations.items.find((item) => item.tenantId === null);
+    if (!globalTranslation) {
+      return null;
+    }
+    return {
+      id: globalTranslation.id,
+      value: globalTranslation.value,
+      status: globalTranslation.status
+    };
+  }
+  async createLanguageTranslation(keyId, languageCode, value) {
+    const mutation = `
+      mutation CreateTranslation($input: CreateTranslationInput!) {
+        createTranslation(input: $input) {
+          id
+          status
+        }
+      }
+    `;
+    const response = await this.client.query(mutation, {
+      input: {
+        keyId,
+        languageCode,
+        value
+      }
+    }, this.context);
+    return response.createTranslation;
+  }
+  async updateLanguageTranslation(id, value, status) {
+    const mutation = `
+      mutation UpdateTranslation($id: ID!, $input: UpdateTranslationInput!) {
+        updateTranslation(id: $id, input: $input) {
+          id
+          status
+        }
+      }
+    `;
+    await this.client.query(mutation, {
+      id,
+      input: {
+        value,
+        status
+      }
+    }, this.context);
+  }
+  /**
+  * Escape regex special characters in a string
+  */
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  /**
+  * Interpolate variables in translation string
+  */
+  interpolate(text, variables) {
+    let result = text;
+    for (const [key, value] of Object.entries(variables)) {
+      const escapedKey = this.escapeRegex(key);
+      const regex = new RegExp(`{{\\s*${escapedKey}\\s*}}`, "g");
+      result = result.replace(regex, String(value));
+    }
+    return result;
+  }
+  /**
+  * Format translation with pluralization
+  */
+  formatPlural(_language, count, translations) {
+    if (count === 0 && translations.zero) {
+      return translations.zero;
+    }
+    if (count === 1) {
+      return translations.one;
+    }
+    return translations.other;
+  }
+  /**
+  * Format date/time for locale
+  */
+  formatDateTime(date, language, options) {
+    const dateObj = typeof date === "string" ? new Date(date) : date;
+    return new Intl.DateTimeFormat(language, options).format(dateObj);
+  }
+  /**
+  * Format number for locale
+  */
+  formatNumber(number, language, options) {
+    return new Intl.NumberFormat(language, options).format(number);
+  }
+  /**
+  * Format currency for locale
+  */
+  formatCurrency(amount, currency, language) {
+    return new Intl.NumberFormat(language, {
+      style: "currency",
+      currency
+    }).format(amount);
+  }
+};
+
+// src/payments/index.ts
+var PaymentsModule = class {
+  static {
+    __name(this, "PaymentsModule");
+  }
+  client;
+  context;
+  constructor(client, context) {
+    this.client = client;
+    this.context = context;
+  }
+  /**
+  * Create payment
+  */
+  async createPayment(options) {
+    if (typeof options.amount !== "number" || options.amount <= 0) {
+      throw new ValidationError("Amount must be a positive number");
+    }
+    if (!options.currency) {
+      throw new ValidationError("Currency is required");
+    }
+    if (!options.paymentMethod) {
+      throw new ValidationError("Payment method is required");
+    }
+    if (!options.customerId) {
+      throw new ValidationError("Customer ID is required");
+    }
+    logger.debug("[Payments] Creating payment", {
+      amount: options.amount,
+      currency: options.currency,
+      customerId: options.customerId
+    });
+    const mutation = `
+      mutation CreatePayment($input: CreatePaymentInput!) {
+        createPayment(input: $input) {
+          id
+          amount
+          currency
+          status
+          paymentMethod
+          customerId
+          description
+          metadata
+          workspaceId
+          organizationId
+          transactionId
+          failureReason
+          createdAt
+          updatedAt
+        }
+      }
+    `;
+    const variables = {
+      input: {
+        amount: options.amount,
+        currency: options.currency,
+        paymentMethod: options.paymentMethod,
+        customerId: options.customerId,
+        description: options.description,
+        metadata: options.metadata,
+        workspaceId: options.workspaceId || this.context.workspaceId,
+        organizationId: options.organizationId
+      }
+    };
+    const response = await this.client.query(mutation, variables, this.context);
+    logger.info("[Payments] Payment created", {
+      paymentId: response.createPayment.id
+    });
+    return response.createPayment;
+  }
+  /**
+  * Get payment by ID
+  */
+  async getPayment(paymentId) {
+    logger.debug("[Payments] Getting payment", {
+      paymentId
+    });
+    const query = `
+      query GetPayment($paymentId: ID!) {
+        getPayment(paymentId: $paymentId) {
+          id
+          amount
+          currency
+          status
+          paymentMethod
+          customerId
+          description
+          metadata
+          workspaceId
+          organizationId
+          transactionId
+          failureReason
+          createdAt
+          updatedAt
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      paymentId
+    }, this.context);
+    return response.getPayment;
+  }
+  /**
+  * Get payments with filters
+  */
+  async getPayments(options) {
+    logger.debug("[Payments] Getting payments", options);
+    const query = `
+      query GetPayments(
+        $customerId: ID
+        $status: PaymentStatus
+        $workspaceId: ID
+        $organizationId: ID
+        $startDate: DateTime
+        $endDate: DateTime
+        $limit: Int
+        $offset: Int
+      ) {
+        getPayments(
+          customerId: $customerId
+          status: $status
+          workspaceId: $workspaceId
+          organizationId: $organizationId
+          startDate: $startDate
+          endDate: $endDate
+          limit: $limit
+          offset: $offset
+        ) {
+          payments {
+            id
+            amount
+            currency
+            status
+            paymentMethod
+            customerId
+            description
+            transactionId
+            createdAt
+            updatedAt
+          }
+          total
+        }
+      }
+    `;
+    const variables = {
+      customerId: options.customerId,
+      status: options.status,
+      workspaceId: options.workspaceId || this.context.workspaceId,
+      organizationId: options.organizationId,
+      startDate: options.startDate,
+      endDate: options.endDate,
+      limit: options.limit || 50,
+      offset: options.offset || 0
+    };
+    const response = await this.client.query(query, variables, this.context);
+    return response.getPayments;
+  }
+  /**
+  * Refund payment
+  */
+  async refundPayment(paymentId, amount, reason) {
+    logger.debug("[Payments] Refunding payment", {
+      paymentId,
+      amount
+    });
+    const mutation = `
+      mutation RefundPayment($paymentId: ID!, $amount: Int, $reason: String) {
+        refundPayment(paymentId: $paymentId, amount: $amount, reason: $reason) {
+          id
+          amount
+          currency
+          status
+          paymentMethod
+          customerId
+          failureReason
+          updatedAt
+        }
+      }
+    `;
+    const response = await this.client.query(mutation, {
+      paymentId,
+      amount,
+      reason
+    }, this.context);
+    logger.info("[Payments] Payment refunded", {
+      paymentId
+    });
+    return response.refundPayment;
+  }
+  /**
+  * Verify payment
+  */
+  async verifyPayment(paymentId, verificationData) {
+    logger.debug("[Payments] Verifying payment", {
+      paymentId
+    });
+    const mutation = `
+      mutation VerifyPayment($paymentId: ID!, $verificationData: JSON!) {
+        verifyPayment(paymentId: $paymentId, verificationData: $verificationData) {
+          verified
+          status
+        }
+      }
+    `;
+    const response = await this.client.query(mutation, {
+      paymentId,
+      verificationData
+    }, this.context);
+    logger.info("[Payments] Payment verified", {
+      paymentId,
+      verified: response.verifyPayment.verified
+    });
+    return response.verifyPayment;
+  }
+  /**
+  * Create subscription
+  */
+  async createSubscription(options) {
+    if (!options.customerId) {
+      throw new ValidationError("Customer ID is required");
+    }
+    if (!options.planId) {
+      throw new ValidationError("Plan ID is required");
+    }
+    if (!options.paymentMethod) {
+      throw new ValidationError("Payment method is required");
+    }
+    logger.debug("[Payments] Creating subscription", {
+      customerId: options.customerId,
+      planId: options.planId
+    });
+    const mutation = `
+      mutation CreateSubscription($input: CreateSubscriptionInput!) {
+        createSubscription(input: $input) {
+          id
+          customerId
+          planId
+          status
+          currentPeriodStart
+          currentPeriodEnd
+          trialEnd
+          cancelledAt
+          endedAt
+          metadata
+          workspaceId
+          organizationId
+          createdAt
+          updatedAt
+        }
+      }
+    `;
+    const variables = {
+      input: {
+        customerId: options.customerId,
+        planId: options.planId,
+        paymentMethod: options.paymentMethod,
+        trialDays: options.trialDays,
+        metadata: options.metadata,
+        workspaceId: options.workspaceId || this.context.workspaceId,
+        organizationId: options.organizationId
+      }
+    };
+    const response = await this.client.query(mutation, variables, this.context);
+    logger.info("[Payments] Subscription created", {
+      subscriptionId: response.createSubscription.id
+    });
+    return response.createSubscription;
+  }
+  /**
+  * Get subscription
+  */
+  async getSubscription(subscriptionId) {
+    logger.debug("[Payments] Getting subscription", {
+      subscriptionId
+    });
+    const query = `
+      query GetSubscription($subscriptionId: ID!) {
+        getSubscription(subscriptionId: $subscriptionId) {
+          id
+          customerId
+          planId
+          status
+          currentPeriodStart
+          currentPeriodEnd
+          trialEnd
+          cancelledAt
+          endedAt
+          metadata
+          workspaceId
+          organizationId
+          createdAt
+          updatedAt
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      subscriptionId
+    }, this.context);
+    return response.getSubscription;
+  }
+  /**
+  * Cancel subscription
+  */
+  async cancelSubscription(subscriptionId, cancelAtPeriodEnd = false) {
+    logger.debug("[Payments] Cancelling subscription", {
+      subscriptionId,
+      cancelAtPeriodEnd
+    });
+    const mutation = `
+      mutation CancelSubscription($subscriptionId: ID!, $cancelAtPeriodEnd: Boolean!) {
+        cancelSubscription(subscriptionId: $subscriptionId, cancelAtPeriodEnd: $cancelAtPeriodEnd) {
+          id
+          status
+          cancelledAt
+          endedAt
+          updatedAt
+        }
+      }
+    `;
+    const response = await this.client.query(mutation, {
+      subscriptionId,
+      cancelAtPeriodEnd
+    }, this.context);
+    logger.info("[Payments] Subscription cancelled", {
+      subscriptionId
+    });
+    return response.cancelSubscription;
+  }
+  /**
+  * Get customer subscriptions
+  */
+  async getCustomerSubscriptions(customerId) {
+    logger.debug("[Payments] Getting customer subscriptions", {
+      customerId
+    });
+    const query = `
+      query GetCustomerSubscriptions($customerId: ID!) {
+        getCustomerSubscriptions(customerId: $customerId) {
+          id
+          customerId
+          planId
+          status
+          currentPeriodStart
+          currentPeriodEnd
+          trialEnd
+          cancelledAt
+          createdAt
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      customerId
+    }, this.context);
+    return response.getCustomerSubscriptions;
+  }
+  /**
+  * Get plans
+  */
+  async getPlans(activeOnly = true) {
+    logger.debug("[Payments] Getting plans", {
+      activeOnly
+    });
+    const query = `
+      query GetPlans($activeOnly: Boolean!) {
+        getPlans(activeOnly: $activeOnly) {
+          id
+          name
+          description
+          amount
+          currency
+          interval
+          intervalCount
+          features
+          metadata
+          active
+          createdAt
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      activeOnly
+    }, this.context);
+    return response.getPlans;
+  }
+  /**
+  * Create payment intent
+  */
+  async createPaymentIntent(options) {
+    logger.debug("[Payments] Creating payment intent", {
+      amount: options.amount,
+      currency: options.currency
+    });
+    const mutation = `
+      mutation CreatePaymentIntent($input: CreatePaymentIntentInput!) {
+        createPaymentIntent(input: $input) {
+          clientSecret
+          paymentIntentId
+        }
+      }
+    `;
+    const response = await this.client.query(mutation, {
+      input: options
+    }, this.context);
+    logger.info("[Payments] Payment intent created", {
+      paymentIntentId: response.createPaymentIntent.paymentIntentId
+    });
+    return response.createPaymentIntent;
+  }
+  /**
+  * Get payment statistics
+  */
+  async getPaymentStats(options) {
+    logger.debug("[Payments] Getting payment statistics", options);
+    const query = `
+      query GetPaymentStats($startDate: DateTime, $endDate: DateTime, $workspaceId: ID) {
+        getPaymentStats(startDate: $startDate, endDate: $endDate, workspaceId: $workspaceId) {
+          totalRevenue
+          totalPayments
+          successfulPayments
+          failedPayments
+          refundedAmount
+          averagePaymentAmount
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      startDate: options?.startDate,
+      endDate: options?.endDate,
+      workspaceId: options?.workspaceId || this.context.workspaceId
+    }, this.context);
+    return response.getPaymentStats;
+  }
+};
+
+// src/bootstrap/index.ts
+var BootstrapModule = class {
+  static {
+    __name(this, "BootstrapModule");
+  }
+  config;
+  startTime;
+  healthCheckInterval;
+  constructor(config) {
+    this.config = config;
+    this.startTime = /* @__PURE__ */ new Date();
+  }
+  /**
+  * Bootstrap the application
+  */
+  async bootstrap() {
+    logger.info("[Bootstrap] Starting application bootstrap", {
+      serviceName: this.config.serviceName,
+      environment: this.config.environment || "development"
+    });
+    try {
+      await this.validateConfiguration();
+      const databaseConnected = await this.connectDatabase();
+      const loadedModules = await this.loadModules();
+      if (this.config.healthCheck) {
+        await this.setupHealthChecks();
+      }
+      this.setupSignalHandlers();
+      const result = {
+        success: true,
+        serviceName: this.config.serviceName || "burdenoff-service",
+        serviceVersion: this.config.serviceVersion || "1.0.0",
+        environment: this.config.environment || "development",
+        startedAt: this.startTime.toISOString(),
+        modules: loadedModules,
+        databaseConnected,
+        healthCheckEnabled: this.config.healthCheck || false
+      };
+      logger.info("[Bootstrap] Application bootstrapped successfully", result);
+      return result;
+    } catch (error) {
+      logger.error("[Bootstrap] Failed to bootstrap application", {
+        error
+      });
+      throw error;
+    }
+  }
+  /**
+  * Validate configuration
+  */
+  async validateConfiguration() {
+    logger.debug("[Bootstrap] Validating configuration");
+    if (!this.config.workspacesApiUrl) {
+      throw new Error("Workspaces API URL is required");
+    }
+    if (this.config.database?.url && !DatabaseModule.validateDatabaseUrl(this.config.database.url)) {
+      throw new Error("Invalid database URL");
+    }
+    logger.debug("[Bootstrap] Configuration validated");
+  }
+  /**
+  * Connect to database
+  */
+  async connectDatabase() {
+    if (!this.config.database) {
+      logger.debug("[Bootstrap] No database configuration provided, skipping");
+      return false;
+    }
+    logger.info("[Bootstrap] Connecting to database");
+    try {
+      const sanitizedUrl = DatabaseModule.sanitizeDatabaseUrl(this.config.database.url);
+      logger.info("[Bootstrap] Database connection configured", {
+        url: sanitizedUrl
+      });
+      return true;
+    } catch (error) {
+      logger.error("[Bootstrap] Failed to connect to database", {
+        error
+      });
+      return false;
+    }
+  }
+  /**
+  * Load modules
+  */
+  async loadModules() {
+    const modules = this.config.modules || [];
+    if (modules.length === 0) {
+      logger.debug("[Bootstrap] No modules to load");
+      return [];
+    }
+    logger.info("[Bootstrap] Loading modules", {
+      modules
+    });
+    const loadedModules = [];
+    for (const moduleName of modules) {
+      try {
+        logger.debug(`[Bootstrap] Loading module: ${moduleName}`);
+        loadedModules.push(moduleName);
+      } catch (error) {
+        logger.error(`[Bootstrap] Failed to load module: ${moduleName}`, {
+          error
+        });
+      }
+    }
+    logger.info("[Bootstrap] Modules loaded", {
+      loaded: loadedModules
+    });
+    return loadedModules;
+  }
+  /**
+  * Setup health checks
+  */
+  async setupHealthChecks() {
+    logger.info("[Bootstrap] Setting up health checks");
+    const interval = this.config.healthCheckInterval || 3e4;
+    this.healthCheckInterval = setInterval(() => {
+      void (async () => {
+        const health = await this.performHealthCheck();
+        if (!health.healthy) {
+          logger.warn("[Bootstrap] Health check failed", health);
+        } else {
+          logger.debug("[Bootstrap] Health check passed", health);
+        }
+      })();
+    }, interval);
+    logger.info("[Bootstrap] Health checks configured", {
+      interval
+    });
+  }
+  /**
+  * Perform health check
+  */
+  async performHealthCheck() {
+    const checks = {};
+    const memUsage = process.memoryUsage();
+    checks.memory = {
+      used: memUsage.heapUsed,
+      total: memUsage.heapTotal,
+      percentage: memUsage.heapUsed / memUsage.heapTotal * 100
+    };
+    checks.uptime = Math.floor((Date.now() - this.startTime.getTime()) / 1e3);
+    const healthy = checks.memory.percentage < 90 && // Less than 90% memory usage
+    checks.uptime > 0;
+    return {
+      healthy,
+      checks,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+  * Setup signal handlers for graceful shutdown
+  */
+  setupSignalHandlers() {
+    logger.debug("[Bootstrap] Setting up signal handlers");
+    const gracefulShutdown = /* @__PURE__ */ __name(async (signal) => {
+      logger.info(`[Bootstrap] Received ${signal}, shutting down gracefully`);
+      if (this.healthCheckInterval) {
+        clearInterval(this.healthCheckInterval);
+      }
+      await this.cleanup();
+      process.exit(0);
+    }, "gracefulShutdown");
+    process.on("SIGTERM", () => {
+      void gracefulShutdown("SIGTERM");
+    });
+    process.on("SIGINT", () => {
+      void gracefulShutdown("SIGINT");
+    });
+    process.on("unhandledRejection", (reason, promise) => {
+      logger.error("[Bootstrap] Unhandled rejection", {
+        reason,
+        promise
+      });
+    });
+    process.on("uncaughtException", (error) => {
+      logger.error("[Bootstrap] Uncaught exception", {
+        error
+      });
+      process.exit(1);
+    });
+  }
+  /**
+  * Cleanup on shutdown
+  */
+  async cleanup() {
+    logger.info("[Bootstrap] Performing cleanup");
+    ContextManager.clearContext();
+    logger.info("[Bootstrap] Cleanup completed");
+  }
+  /**
+  * Get application info
+  */
+  getInfo() {
+    return {
+      serviceName: this.config.serviceName || "burdenoff-service",
+      serviceVersion: this.config.serviceVersion || "1.0.0",
+      environment: this.config.environment || "development",
+      uptime: Math.floor((Date.now() - this.startTime.getTime()) / 1e3),
+      startedAt: this.startTime.toISOString()
+    };
+  }
+  /**
+  * Setup default context
+  */
+  setupDefaultContext(context) {
+    logger.debug("[Bootstrap] Setting up default context", context);
+    ContextManager.setContext(context);
+  }
+  /**
+  * Create context middleware (for Elysia/HTTP frameworks)
+  */
+  createContextMiddleware() {
+    return async (req, _res, next) => {
+      const context = this.extractContextFromRequest(req);
+      ContextManager.setContext(context);
+      next();
+    };
+  }
+  /**
+  * Extract context from request
+  */
+  extractContextFromRequest(req) {
+    const context = {};
+    if (req.user) {
+      context.actorId = req.user.user_id;
+      context.workspaceId = req.user.workspace_id;
+      context.tenantId = req.user.tenant_endpoint;
+    }
+    const getHeader = /* @__PURE__ */ __name((key) => {
+      const value = req.headers[key.toLowerCase()];
+      return Array.isArray(value) ? value[0] : value;
+    }, "getHeader");
+    const authHeader = getHeader("authorization");
+    if (authHeader) {
+      context.token = authHeader.replace("Bearer ", "");
+    }
+    const workspaceId = getHeader("x-workspace-id");
+    if (workspaceId && !context.workspaceId) {
+      context.workspaceId = workspaceId;
+    }
+    const productId = getHeader("x-product-id");
+    if (productId) {
+      context.productId = productId;
+    }
+    const projectId = getHeader("x-project-id");
+    if (projectId) {
+      context.projectId = projectId;
+    }
+    const appId = getHeader("x-app-id");
+    if (appId) {
+      context.appId = appId;
+    }
+    return context;
+  }
+  /**
+  * Load GraphQL schema
+  */
+  async loadSchema(schemaPath) {
+    logger.info("[Bootstrap] Loading GraphQL schema", {
+      schemaPath
+    });
+    try {
+      logger.info("[Bootstrap] Schema loaded successfully");
+      return true;
+    } catch (error) {
+      logger.error("[Bootstrap] Failed to load schema", {
+        error
+      });
+      return false;
+    }
+  }
+  /**
+  * Register shutdown hook
+  */
+  onShutdown(callback) {
+    const originalHandler = process.listeners("SIGTERM")[0];
+    process.removeAllListeners("SIGTERM");
+    process.on("SIGTERM", () => {
+      void (async () => {
+        await callback();
+        if (typeof originalHandler === "function") {
+          originalHandler();
+        }
+      })();
+    });
+  }
+  /**
+  * Check if application is ready
+  */
+  async isReady() {
+    const health = await this.performHealthCheck();
+    return health.healthy;
+  }
+  /**
+  * Get metrics
+  */
+  getMetrics() {
+    return {
+      memory: process.memoryUsage(),
+      uptime: Math.floor((Date.now() - this.startTime.getTime()) / 1e3),
+      cpu: process.cpuUsage()
+    };
+  }
+};
+function createBootstrap(config) {
+  return new BootstrapModule(config);
+}
+__name(createBootstrap, "createBootstrap");
+
+// src/client/tenant-backend.ts
+var TenantBackendClient = class {
+  static {
+    __name(this, "TenantBackendClient");
+  }
+  graphqlClient;
+  config;
+  /** Notifications module for sending notifications via tenant backend */
+  notifications;
+  constructor(config) {
+    this.config = config;
+    const sdkConfig = {
+      workspacesApiUrl: config.workspacesBackendUrl || "http://localhost:4000/graphql",
+      tenantApiUrl: config.tenantBackendUrl
+    };
+    this.graphqlClient = new BurdenoffGraphQLClient(sdkConfig, {});
+    this.notifications = new TenantNotificationsModule(this.graphqlClient, {});
+    logger.info("[TenantBackend] Client initialized using be-sdk", {
+      tenantUrl: config.tenantBackendUrl,
+      workspacesUrl: config.workspacesBackendUrl,
+      hasApiKey: !!config.apiKey
+    });
+  }
+  /**
+  * Update authentication token
+  *
+  * @param token - JWT token for authentication
+  */
+  setAuthToken(token) {
+    this.graphqlClient.updateContext({
+      token
+    });
+    logger.debug("[TenantBackend] Authentication token updated");
+  }
+  /**
+  * Execute raw GraphQL query against tenant backend
+  *
+  * @param query - GraphQL query string
+  * @param variables - Query variables
+  * @returns Query result
+  *
+  * @example
+  * ```typescript
+  * const result = await client.query(`
+  *   query GetTemplate($slug: String!) {
+  *     notificationTemplate(slug: $slug) {
+  *       id
+  *       slug
+  *       subject
+  *     }
+  *   }
+  * `, { slug: 'user-welcome' });
+  * ```
+  */
+  async query(query, variables) {
+    return this.graphqlClient.tenantQuery(query, variables);
+  }
+  /**
+  * Health check
+  *
+  * @returns True if tenant backend is reachable, false otherwise
+  */
+  async healthCheck() {
+    try {
+      const query = `
+        query HealthCheck {
+          __typename
+        }
+      `;
+      await this.graphqlClient.tenantQuery(query);
+      return true;
+    } catch (error) {
+      logger.error("[TenantBackend] Health check failed", {
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      return false;
+    }
+  }
+  /**
+  * Get GraphQL client for advanced usage
+  *
+  * @returns Underlying BurdenoffGraphQLClient
+  */
+  getClient() {
+    return this.graphqlClient;
+  }
+  /**
+  * Get client configuration
+  *
+  * @returns Client configuration
+  */
+  getConfig() {
+    return {
+      ...this.config
+    };
+  }
+};
+function createTenantBackendClient(config) {
+  return new TenantBackendClient(config);
+}
+__name(createTenantBackendClient, "createTenantBackendClient");
+
+// src/index.ts
+var BurdenoffSDK = class {
+  static {
+    __name(this, "BurdenoffSDK");
+  }
+  client;
+  defaultContext;
+  // NATS publisher state
+  natsPublisher = null;
+  natsInitPromise = null;
+  natsConfig = null;
+  // Initialization state
+  initializationPromise = null;
+  isShuttingDown = false;
+  /** Authentication module */
+  auth;
+  /** Notifications module (workspaces-backend) */
+  notifications;
+  /** Tenant Notifications module (tenant-backend - RECOMMENDED) */
+  tenantNotifications;
+  /** RBAC module */
+  rbac;
+  /** Activity tracking module */
+  activity;
+  /** Usage & Quota module */
+  usage;
+  /** Unified Tracker module (MOST IMPORTANT - use this for most operations) */
+  tracker;
+  /** Database helpers module */
+  database;
+  /** Events/Queue module */
+  events;
+  /** Graph integration module */
+  graph;
+  /** Search module */
+  search;
+  /** Translation module */
+  translation;
+  /** Payments module */
+  payments;
+  /** Temporal workflow orchestration module (lazy-loaded) */
+  _temporal = null;
+  _temporalPromise = null;
+  _temporalConfig = null;
+  /**
+  * Get Temporal workflow orchestration module (lazy-loaded)
+  * Only loads @temporalio/client when this method is called
+  *
+  * @returns Promise resolving to TemporalModule
+  * @example
+  * ```typescript
+  * const temporal = await sdk.getTemporalModule();
+  * await temporal.startWorkflow('myWorkflow', { ... });
+  * ```
+  */
+  async getTemporalModule() {
+    if (this._temporal) {
+      return this._temporal;
+    }
+    if (!this._temporalPromise) {
+      this._temporalPromise = this.loadTemporalModule();
+    }
+    return this._temporalPromise;
+  }
+  /**
+  * Load temporal module dynamically
+  * @private
+  */
+  async loadTemporalModule() {
+    const { TemporalModule: TM } = await import('./temporal/index.js');
+    this._temporal = this._temporalConfig?.moduleType ? new TM({
+      moduleType: this._temporalConfig.moduleType,
+      address: this._temporalConfig.address,
+      namespace: this._temporalConfig.namespace,
+      taskQueue: this._temporalConfig.taskQueue
+    }) : TM.fromEnv();
+    return this._temporal;
+  }
+  /** Logger instance */
+  logger;
+  /** Context manager */
+  context;
+  /**
+  * Create SDK instance
+  */
+  constructor(config, defaultContext = {}) {
+    this.client = new BurdenoffGraphQLClient(config, defaultContext);
+    this.defaultContext = defaultContext;
+    this.logger = logger;
+    if (config.logger) {
+      this.logger.setLevel(config.logger.level);
+      this.logger.setConsoleEnabled(config.logger.console);
+      if (config.logger.transport) {
+        this.logger.addTransport(config.logger.transport);
+      }
+    }
+    this.context = ContextManager;
+    if (Object.keys(defaultContext).length > 0) {
+      ContextManager.setContext(defaultContext);
+    }
+    this.auth = new AuthModule(this.client, defaultContext);
+    this.notifications = new NotificationsModule(this.client, defaultContext);
+    this.tenantNotifications = new TenantNotificationsModule(this.client, defaultContext);
+    this.rbac = new RBACModule(this.client, defaultContext);
+    this.activity = new ActivityModule(this.client, defaultContext);
+    this.usage = new UsageModule(this.client, defaultContext);
+    this.tracker = new TrackerModule(this.client, defaultContext);
+    this.database = DatabaseModule;
+    this.events = new EventsModule(this.client, defaultContext);
+    this.graph = new GraphModule(this.client, defaultContext);
+    this.search = new SearchModule(this.client, defaultContext);
+    this.translation = new TranslationModule(this.client, defaultContext);
+    this.payments = new PaymentsModule(this.client, defaultContext);
+    if (config.temporalModuleType) {
+      this._temporalConfig = {
+        moduleType: config.temporalModuleType,
+        address: config.temporalAddress,
+        namespace: config.temporalNamespace,
+        taskQueue: config.temporalTaskQueue
+      };
+    }
+    if (config.nats) {
+      this.natsConfig = {
+        autoConnect: true,
+        maxReconnectAttempts: -1,
+        reconnectTimeWait: 2e3,
+        ...config.nats
+      };
+    }
+    logger.info("[SDK] Burdenoff SDK initialized", {
+      workspacesApiUrl: config.workspacesApiUrl,
+      tenantApiUrl: config.tenantApiUrl,
+      hasDefaultContext: Object.keys(defaultContext).length > 0,
+      hasNatsConfig: !!config.nats,
+      hasTemporalConfig: !!config.temporalModuleType
+    });
+    this.scheduleBackgroundInit();
+  }
+  /**
+  * Schedule background initialization outside constructor
+  * Uses queueMicrotask to defer async work while maintaining initialization order
+  * @private
+  */
+  scheduleBackgroundInit() {
+    queueMicrotask(() => {
+      this.initializationPromise = this.initializeAsync();
+    });
+  }
+  /**
+  * Update SDK context
+  */
+  setContext(context) {
+    this.defaultContext = {
+      ...this.defaultContext,
+      ...context
+    };
+    this.client.updateContext(context);
+    ContextManager.setContext(this.defaultContext);
+  }
+  /**
+  * Get current context
+  */
+  getContext() {
+    return ContextManager.getContext();
+  }
+  /**
+  * Run function with specific context
+  */
+  async withContext(context, fn) {
+    return ContextManager.withContext(context, fn);
+  }
+  /**
+  * Background initialization for NATS and other async resources
+  * @private
+  */
+  async initializeAsync() {
+    const promises = [];
+    if (this.natsConfig?.autoConnect) {
+      promises.push(this.initializeNats().catch((error) => {
+        logger.warn("[SDK] Failed to auto-connect to NATS", {
+          error
+        });
+      }));
+    }
+    await Promise.allSettled(promises);
+  }
+  /**
+  * Initialize NATS publisher
+  * @private
+  */
+  async initializeNats() {
+    if (!this.natsConfig || this.natsPublisher) return;
+    const natsUrl = this.natsConfig.url || this.natsConfig.servers && this.natsConfig.servers[0] || "nats://localhost:4222";
+    const publisherConfig = {
+      type: "nats",
+      url: natsUrl,
+      user: this.natsConfig.user,
+      password: this.natsConfig.password,
+      token: this.natsConfig.token,
+      name: this.natsConfig.name || "burdenoff-sdk-publisher",
+      maxReconnectAttempts: this.natsConfig.maxReconnectAttempts ?? -1,
+      reconnectTimeWait: this.natsConfig.reconnectTimeWait ?? 2e3
+    };
+    this.natsPublisher = EventQueueFactory.createPublisher(publisherConfig);
+    await this.natsPublisher.connect();
+    logger.info("[SDK] NATS publisher initialized", {
+      url: natsUrl,
+      name: this.natsConfig.name
+    });
+  }
+  /**
+  * Get NATS publisher instance (lazy initialization)
+  *
+  * @example
+  * ```typescript
+  * const publisher = await sdk.getNatsPublisher();
+  * await publisher.publish({
+  *   subject: 'events.user.created',
+  *   data: { userId: 'user-123' }
+  * });
+  * ```
+  */
+  async getNatsPublisher() {
+    if (this.natsPublisher) return this.natsPublisher;
+    if (!this.natsConfig) {
+      throw new Error("[SDK] NATS not configured - provide nats config in SDKConfig");
+    }
+    if (!this.natsInitPromise) {
+      this.natsInitPromise = this.initializeNats();
+    }
+    await this.natsInitPromise;
+    if (!this.natsPublisher) {
+      throw new Error("[SDK] NATS initialization failed");
+    }
+    return this.natsPublisher;
+  }
+  /**
+  * Wait for SDK initialization to complete
+  *
+  * @example
+  * ```typescript
+  * await sdk.waitForReady();
+  * ```
+  */
+  async waitForReady() {
+    if (this.initializationPromise) {
+      await this.initializationPromise;
+    }
+  }
+  /**
+  * Check NATS health status
+  *
+  * @example
+  * ```typescript
+  * const health = await sdk.isNatsHealthy();
+  * if (health.status === 'healthy') {
+  *   console.log('NATS is connected');
+  * }
+  * ```
+  */
+  async isNatsHealthy() {
+    if (!this.natsConfig) {
+      return {
+        status: "not_configured",
+        connected: false
+      };
+    }
+    if (!this.natsPublisher) {
+      return {
+        status: "unhealthy",
+        connected: false,
+        url: this.natsConfig.url,
+        details: {
+          reason: "Not initialized"
+        }
+      };
+    }
+    try {
+      const healthCheck = await this.natsPublisher.healthCheck();
+      return {
+        status: healthCheck.status,
+        connected: this.natsPublisher.isConnected(),
+        url: this.natsConfig.url,
+        details: healthCheck.details
+      };
+    } catch (error) {
+      return {
+        status: "unhealthy",
+        connected: false,
+        url: this.natsConfig.url,
+        details: {
+          error: error instanceof Error ? error.message : String(error)
+        }
+      };
+    }
+  }
+  /**
+  * Check Temporal health status
+  *
+  * @example
+  * ```typescript
+  * const health = await sdk.isTemporalHealthy();
+  * if (health.status === 'healthy') {
+  *   console.log('Temporal is connected');
+  * }
+  * ```
+  */
+  async isTemporalHealthy() {
+    if (!this._temporal) {
+      return {
+        status: "not_configured",
+        connected: false
+      };
+    }
+    const config = this._temporal.getConfig();
+    if (!config.address) {
+      return {
+        status: "not_configured",
+        connected: false
+      };
+    }
+    try {
+      const client = this._temporal.getClient();
+      const connected = client.isClientConnected();
+      return {
+        status: connected ? "healthy" : "unhealthy",
+        connected,
+        address: config.address,
+        namespace: config.namespace,
+        details: {
+          taskQueue: config.taskQueue
+        }
+      };
+    } catch (error) {
+      return {
+        status: "unhealthy",
+        connected: false,
+        address: config.address,
+        namespace: config.namespace,
+        details: {
+          error: error instanceof Error ? error.message : String(error)
+        }
+      };
+    }
+  }
+  /**
+  * Get overall SDK health status
+  *
+  * @example
+  * ```typescript
+  * const health = await sdk.getHealthStatus();
+  * console.log('NATS:', health.nats.status);
+  * console.log('Temporal:', health.temporal.status);
+  * ```
+  */
+  async getHealthStatus() {
+    const [nats, temporal] = await Promise.all([
+      this.isNatsHealthy(),
+      this.isTemporalHealthy()
+    ]);
+    return {
+      nats,
+      temporal
+    };
+  }
+  /**
+  * Graceful shutdown - disconnect all resources
+  *
+  * @example
+  * ```typescript
+  * // On application shutdown
+  * await sdk.shutdown({ timeout: 5000, force: true });
+  * ```
+  */
+  async shutdown(options = {}) {
+    if (this.isShuttingDown) {
+      logger.warn("[SDK] Shutdown already in progress");
+      return;
+    }
+    this.isShuttingDown = true;
+    const timeout = options.timeout ?? 5e3;
+    const force = options.force ?? true;
+    logger.info("[SDK] Starting graceful shutdown", {
+      timeout,
+      force
+    });
+    const shutdownPromises = [];
+    if (this.natsPublisher) {
+      shutdownPromises.push(this.natsPublisher.disconnect().catch((error) => {
+        logger.error("[SDK] Error disconnecting NATS", {
+          error
+        });
+      }));
+    }
+    if (this._temporal) {
+      shutdownPromises.push(this._temporal.disconnect().catch((error) => {
+        logger.error("[SDK] Error disconnecting Temporal", {
+          error
+        });
+      }));
+    }
+    try {
+      await Promise.race([
+        Promise.allSettled(shutdownPromises),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("[SDK] Shutdown timeout exceeded")), timeout))
+      ]);
+      logger.info("[SDK] Shutdown completed successfully");
+    } catch (error) {
+      if (!force) {
+        throw error;
+      }
+      logger.warn("[SDK] Shutdown timeout exceeded, forcing shutdown", {
+        error
+      });
+    }
+  }
+  /**
+  * Create bootstrap instance
+  */
+  static createBootstrap(config) {
+    return createBootstrap(config);
+  }
+};
+var index_default = BurdenoffSDK;
+function createSDK(config, context) {
+  return new BurdenoffSDK(config, context);
+}
+__name(createSDK, "createSDK");
+
+export { BootstrapModule, BurdenoffGraphQLClient, BurdenoffSDK, ContextManager, PaymentsModule, SearchModule, TenantBackendClient, TranslationModule, createBootstrap, createSDK, createTenantBackendClient, index_default as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map