@dv4resi/dvss-backend-module-offering-im 0.0.7 → 0.0.8

package/dist/index.js

@@ -7,6 +7,9 @@ var dvssBackendModuleUtility = require('@dv4resi/dvss-backend-module-utility');
 var axios = require('@nestjs/axios');
 var config = require('@nestjs/config');
 var rxjs = require('rxjs');
+var dvssBackendModuleDatastore = require('@dv4resi/dvss-backend-module-datastore');
+var capabilityIntegration_model = require('@dv4resi/dvss-backend-module-datastore/dist/datastore/models/capability-integration.model');
+var models = require('@dv4resi/dvss-backend-module-datastore/dist/datastore/models');
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
@@ -217,7 +220,7 @@ function _ts_metadata6(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata6, "_ts_metadata");
-var IntegrationRequestLoggerService = class _IntegrationRequestLoggerService {
+exports.IntegrationRequestLoggerService = class _IntegrationRequestLoggerService {
   static {
     __name(this, "IntegrationRequestLoggerService");
   }
@@ -237,7 +240,7 @@ var IntegrationRequestLoggerService = class _IntegrationRequestLoggerService {
       integrationId: logData.integrationId,
       method,
       url,
-      headers: this.sanitizeHeaders(headers),
+      headers,
       requestBody,
       timestamp: logData.timestamp || /* @__PURE__ */ new Date()
     });
@@ -265,7 +268,7 @@ var IntegrationRequestLoggerService = class _IntegrationRequestLoggerService {
   * @param logData - The error log data to be logged
   */
   logError(logData) {
-    const { loggedInUserId, method, url, statusCode, duration, error } = logData;
+    const { loggedInUserId, method, url, statusCode, duration, error, responseBody } = logData;
     this.logger.error(loggedInUserId || dvssBackendModuleUtility.SYSTEM_USER_ID, this.logError.name, this.className, `Integration API Error: ${method} ${url} - ${statusCode || "N/A"} (${duration || 0}ms)`, {
       integrationId: logData.integrationId,
       method,
@@ -273,6 +276,7 @@ var IntegrationRequestLoggerService = class _IntegrationRequestLoggerService {
       statusCode,
       duration,
       error,
+      responseBody,
       timestamp: logData.timestamp || /* @__PURE__ */ new Date()
     });
   }
@@ -291,41 +295,14 @@ var IntegrationRequestLoggerService = class _IntegrationRequestLoggerService {
       this.logRequest(logData);
     }
   }
-  /**
-  * Sanitize headers to remove sensitive information
-  *
-  * @param headers - The headers to sanitize
-  * @returns Sanitized headers
-  */
-  sanitizeHeaders(headers) {
-    if (!headers) {
-      return void 0;
-    }
-    const sanitized = {
-      ...headers
-    };
-    const sensitiveKeys = [
-      "authorization",
-      "api-key",
-      "apikey",
-      "x-api-key",
-      "cookie"
-    ];
-    for (const key of Object.keys(sanitized)) {
-      if (sensitiveKeys.includes(key.toLowerCase())) {
-        sanitized[key] = "***REDACTED***";
-      }
-    }
-    return sanitized;
-  }
 };
-IntegrationRequestLoggerService = _ts_decorate7([
+exports.IntegrationRequestLoggerService = _ts_decorate7([
   common.Injectable(),
   _ts_metadata6("design:type", Function),
   _ts_metadata6("design:paramtypes", [
     typeof dvssBackendModuleUtility.LoggerService === "undefined" ? Object : dvssBackendModuleUtility.LoggerService
   ])
-], IntegrationRequestLoggerService);
+], exports.IntegrationRequestLoggerService);
 function _ts_decorate8(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -333,7 +310,7 @@ function _ts_decorate8(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate8, "_ts_decorate");
-var RateLimiterService = class {
+exports.RateLimiterService = class RateLimiterService {
   static {
     __name(this, "RateLimiterService");
   }
@@ -345,9 +322,9 @@ var RateLimiterService = class {
   async validateAndEnforceRateLimit() {
   }
 };
-RateLimiterService = _ts_decorate8([
+exports.RateLimiterService = _ts_decorate8([
   common.Injectable()
-], RateLimiterService);
+], exports.RateLimiterService);
 
 // ../../packages/dvss-integration-libs/src/integration-traffic-router/constants/http.constant.ts
 var HTTP_METHOD = /* @__PURE__ */ (function(HTTP_METHOD2) {
@@ -435,10 +412,15 @@ exports.TrafficGatewayService = class TrafficGatewayService {
         requestBody: request.body,
         loggedInUserId,
         timestamp: /* @__PURE__ */ new Date(),
-        error: errorDetails.message || String(error),
+        error: errorDetails.apiMessage,
         statusCode: errorDetails.statusCode,
-        duration
+        duration,
+        responseBody: errorDetails.responseBody
       });
+      const err = error;
+      err.apiMessage = errorDetails.message;
+      err.statusCode = errorDetails.statusCode;
+      err.message = errorDetails.apiMessage;
       throw error;
     }
   }
@@ -528,17 +510,35 @@ exports.TrafficGatewayService = class TrafficGatewayService {
     }
   }
   /**
-  * Extract error details from an error object
+  * Extract error details from an error object (e.g. Axios error).
+  * Provider-agnostic: derives apiMessage from common response shapes so any integration
+  * (Trybe, OAuth, REST, etc.) gets a readable reason. Callers can use statusCode and
+  * responseBody to map to their own exceptions (e.g. 404 -> RESOURCE_NOT_FOUND).
+  *
+  * Supported response.data fields (first string wins): message, error_description,
+  * error, detail, msg.
   *
   * @private
   * @param error - The error object
-  * @returns Extracted error details
+  * @returns Extracted error details including apiMessage for logging and callers
   */
   extractErrorDetails(error) {
     const errorObject = error;
+    const responseData = errorObject.response?.data;
+    const data = typeof responseData === "object" && responseData !== null ? responseData : void 0;
+    const firstString = /* @__PURE__ */ __name((...keys) => {
+      for (const k of keys) {
+        const v = data?.[k];
+        if (typeof v === "string" && v.trim()) return v;
+      }
+      return void 0;
+    }, "firstString");
+    const apiMessage = firstString("message", "error_description", "error", "detail", "msg") || errorObject.message || "API error";
     return {
       message: errorObject.message,
-      statusCode: errorObject.status || errorObject.response?.status
+      statusCode: errorObject.status || errorObject.response?.status,
+      responseBody: errorObject.response?.data,
+      apiMessage
     };
   }
 };
@@ -547,8 +547,8 @@ exports.TrafficGatewayService = _ts_decorate9([
   _ts_metadata7("design:type", Function),
   _ts_metadata7("design:paramtypes", [
     typeof axios.HttpService === "undefined" ? Object : axios.HttpService,
-    typeof IntegrationRequestLoggerService === "undefined" ? Object : IntegrationRequestLoggerService,
-    typeof RateLimiterService === "undefined" ? Object : RateLimiterService
+    typeof exports.IntegrationRequestLoggerService === "undefined" ? Object : exports.IntegrationRequestLoggerService,
+    typeof exports.RateLimiterService === "undefined" ? Object : exports.RateLimiterService
   ])
 ], exports.TrafficGatewayService);
 
@@ -582,13 +582,13 @@ exports.IntegrationLibsModule = _ts_decorate10([
     providers: [
       AppService3,
       exports.TrafficGatewayService,
-      IntegrationRequestLoggerService,
-      RateLimiterService
+      exports.IntegrationRequestLoggerService,
+      exports.RateLimiterService
     ],
     exports: [
       exports.TrafficGatewayService,
-      IntegrationRequestLoggerService,
-      RateLimiterService
+      exports.IntegrationRequestLoggerService,
+      exports.RateLimiterService
     ]
   })
 ], exports.IntegrationLibsModule);
@@ -596,13 +596,51 @@ exports.IntegrationLibsModule = _ts_decorate10([
 // ../../packages/dvss-integration-libs/src/integration-traffic-router/constants/traffic-router.constant.ts
 var TRAFFIC_ROUTER_CONFIGURATION_STORE_KEY = "traffic-router-configuration-store";
 
-// ../../packages/dvss-integration-libs/src/integration-operation-skeletons/auth/auth.base.ts
+// ../../packages/dvss-integration-libs/src/integration-operation-skeletons/capabilities/auth/auth.base.ts
 var BaseAuth = class {
   static {
     __name(this, "BaseAuth");
   }
 };
 
+// ../../packages/dvss-integration-libs/src/integration-operation-skeletons/models/credit-management.model.ts
+var CREDIT_TYPE_ENUM = /* @__PURE__ */ (function(CREDIT_TYPE_ENUM2) {
+  CREDIT_TYPE_ENUM2["COUPON"] = "COUPON";
+  CREDIT_TYPE_ENUM2["AMOUNT"] = "AMOUNT";
+  return CREDIT_TYPE_ENUM2;
+})({});
+var CREDIT_STATUS_ENUM = /* @__PURE__ */ (function(CREDIT_STATUS_ENUM2) {
+  CREDIT_STATUS_ENUM2["ACTIVE"] = "ACTIVE";
+  CREDIT_STATUS_ENUM2["REDEEMED"] = "REDEEMED";
+  CREDIT_STATUS_ENUM2["EXPIRED"] = "EXPIRED";
+  CREDIT_STATUS_ENUM2["REVOKED"] = "REVOKED";
+  return CREDIT_STATUS_ENUM2;
+})({});
+var CREDIT_FILTER_BY_ENUM = /* @__PURE__ */ (function(CREDIT_FILTER_BY_ENUM2) {
+  CREDIT_FILTER_BY_ENUM2["TYPE"] = "TYPE";
+  CREDIT_FILTER_BY_ENUM2["STATUS"] = "STATUS";
+  return CREDIT_FILTER_BY_ENUM2;
+})({});
+
+// ../../packages/dvss-integration-libs/src/integration-operation-skeletons/models/capability-integration.model.ts
+var INTEGRATION_PROVIDER_ENUM = /* @__PURE__ */ (function(INTEGRATION_PROVIDER_ENUM2) {
+  INTEGRATION_PROVIDER_ENUM2["TRYBE"] = "TRYBE";
+  return INTEGRATION_PROVIDER_ENUM2;
+})({});
+
+// ../../packages/dvss-integration-libs/src/integration-operation-skeletons/models/wellness-management.model.ts
+var BOOKABLE_ITEM_TYPE_ENUM = /* @__PURE__ */ (function(BOOKABLE_ITEM_TYPE_ENUM2) {
+  BOOKABLE_ITEM_TYPE_ENUM2["APPOINTMENT"] = "APPOINTMENT";
+  BOOKABLE_ITEM_TYPE_ENUM2["SESSION"] = "SESSION";
+  BOOKABLE_ITEM_TYPE_ENUM2["COURSE"] = "COURSE";
+  return BOOKABLE_ITEM_TYPE_ENUM2;
+})({});
+var BOOKABLE_ITEM_STATUS_ENUM = /* @__PURE__ */ (function(BOOKABLE_ITEM_STATUS_ENUM2) {
+  BOOKABLE_ITEM_STATUS_ENUM2["ACTIVE"] = "ACTIVE";
+  BOOKABLE_ITEM_STATUS_ENUM2["INACTIVE"] = "INACTIVE";
+  return BOOKABLE_ITEM_STATUS_ENUM2;
+})({});
+
 // ../../packages/dvss-integration-libs/src/integration-operation-skeletons/capabilities/wellness/wellness-management.base.ts
 var BaseWellnessManagement = class {
   static {
@@ -700,79 +738,1582 @@ var BasePaymentUserManagement = class {
     __name(this, "BasePaymentUserManagement");
   }
 };
-
-// ../../packages/dvss-integration-libs/src/integration-operation-skeletons/capabilities/membership/subcapabilities/customer-management.base.ts
-var BaseMembershipCustomerManagement = class {
+
+// ../../packages/dvss-integration-libs/src/integration-operation-skeletons/capabilities/membership/subcapabilities/customer-management.base.ts
+var BaseMembershipCustomerManagement = class {
+  static {
+    __name(this, "BaseMembershipCustomerManagement");
+  }
+};
+
+// ../../packages/dvss-integration-libs/src/integration-operation-skeletons/capabilities/membership/subcapabilities/membership-management.base.ts
+var BaseMembershipManagement = class {
+  static {
+    __name(this, "BaseMembershipManagement");
+  }
+};
+
+// ../../packages/dvss-integration-libs/src/integration-operation-skeletons/capabilities/integration-configuration/integration-configuration.base.ts
+var BaseIntegrationConfiguration = class {
+  static {
+    __name(this, "BaseIntegrationConfiguration");
+  }
+  integrationConfigurationDao;
+  commonValidationDatabaseService;
+  constructor(integrationConfigurationDao, commonValidationDatabaseService) {
+    this.integrationConfigurationDao = integrationConfigurationDao;
+    this.commonValidationDatabaseService = commonValidationDatabaseService;
+  }
+  /**
+  * Validates add-capability-integration input (project, property, parent, capability, provider, configuredFor).
+  * Logic copied from project-ms CapabilityIntegrationService.validateAddCapabilityIntegrationInput.
+  */
+  async validateAddCapabilityIntegrationInput(input, context) {
+    await this.commonValidationDatabaseService.getProject({
+      projectId: input.projectId
+    });
+    if (input.propertyId != null) {
+      await this.commonValidationDatabaseService.getProperty({
+        propertyId: input.propertyId,
+        projectId: input.projectId
+      });
+    }
+    if (input.parentId != null) {
+      const parentIntegration = await this.integrationConfigurationDao.getCapabilityIntegration({
+        capabilityIntegrationId: input.parentId
+      }, context.loggedInUserId);
+      if (!parentIntegration) {
+        throw new Error("Parent capability integration not found");
+      }
+    }
+    const [capability, capabilityProvider] = await Promise.all([
+      this.integrationConfigurationDao.getCapability({
+        capabilityId: input.capabilityId
+      }, context.loggedInUserId),
+      this.integrationConfigurationDao.getCapabilityProvider({
+        capabilityProviderId: input.capabilityProviderId
+      }, context.loggedInUserId)
+    ]);
+    if (!capability) {
+      throw new Error("Capability not found");
+    }
+    if (!capabilityProvider) {
+      throw new Error("Capability provider not found");
+    }
+    if (capability.providerId !== capabilityProvider.id) {
+      throw new Error(`Capability provider mismatch: capabilityId=${capability.id}, capabilityProviderId=${capability.providerId}`);
+    }
+    return {
+      capability: {
+        id: capability.id,
+        type: capability.type,
+        category: capability.category,
+        providerId: capability.providerId
+      },
+      capabilityProvider: {
+        id: capabilityProvider.id
+      }
+    };
+  }
+  /**
+  * Add a capability integration (validate then persist via DAO).
+  * Same name as project MS call: addCapabilityIntegration.
+  */
+  async addCapabilityIntegration(input, context) {
+    const { capability, capabilityProvider } = await this.validateAddCapabilityIntegrationInput(input, context);
+    const addCapabilityIntegrationInput = {
+      ...input,
+      providerId: capabilityProvider.id,
+      createdBy: context.loggedInUserId,
+      type: capability.type,
+      category: capability.category,
+      availableFor: input.availableFor,
+      configuredFor: input.configuredFor
+    };
+    const result = await this.integrationConfigurationDao.addCapabilityIntegration(addCapabilityIntegrationInput, context.loggedInUserId);
+    if (!result || !result.id) {
+      throw new Error("Failed to add capability integration");
+    }
+    return result;
+  }
+  /**
+  * Update a capability integration (add audit then persist via DAO).
+  * Same as project MS call: updateCapabilityIntegration.
+  * DAO logic copied from project-ms CapabilityIntegrationDao.updateCapabilityIntegration.
+  */
+  async updateCapabilityIntegration(id, updateData, context) {
+    const updateDataWithAudit = {
+      ...updateData,
+      updatedBy: context.loggedInUserId
+    };
+    return await this.integrationConfigurationDao.updateCapabilityIntegration({
+      id,
+      updateData: updateDataWithAudit
+    }, context.loggedInUserId);
+  }
+};
+
+// ../../node_modules/drizzle-orm/entity.js
+var entityKind = /* @__PURE__ */ Symbol.for("drizzle:entityKind");
+function is(value, type) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (value instanceof type) {
+    return true;
+  }
+  if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
+    throw new Error(`Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`);
+  }
+  let cls = value.constructor;
+  if (cls) {
+    while (cls) {
+      if (entityKind in cls && cls[entityKind] === type[entityKind]) {
+        return true;
+      }
+      cls = Object.getPrototypeOf(cls);
+    }
+  }
+  return false;
+}
+__name(is, "is");
+
+// ../../node_modules/drizzle-orm/column.js
+var Column = class Column2 {
+  static {
+    __name(this, "Column");
+  }
+  constructor(table, config3) {
+    this.table = table;
+    this.config = config3;
+    this.name = config3.name;
+    this.notNull = config3.notNull;
+    this.default = config3.default;
+    this.defaultFn = config3.defaultFn;
+    this.onUpdateFn = config3.onUpdateFn;
+    this.hasDefault = config3.hasDefault;
+    this.primary = config3.primaryKey;
+    this.isUnique = config3.isUnique;
+    this.uniqueName = config3.uniqueName;
+    this.uniqueType = config3.uniqueType;
+    this.dataType = config3.dataType;
+    this.columnType = config3.columnType;
+    this.generated = config3.generated;
+    this.generatedIdentity = config3.generatedIdentity;
+  }
+  static [entityKind] = "Column";
+  name;
+  primary;
+  notNull;
+  default;
+  defaultFn;
+  onUpdateFn;
+  hasDefault;
+  isUnique;
+  uniqueName;
+  uniqueType;
+  dataType;
+  columnType;
+  enumValues = void 0;
+  generated = void 0;
+  generatedIdentity = void 0;
+  config;
+  mapFromDriverValue(value) {
+    return value;
+  }
+  mapToDriverValue(value) {
+    return value;
+  }
+  // ** @internal */
+  shouldDisableInsert() {
+    return this.config.generated !== void 0 && this.config.generated.type !== "byDefault";
+  }
+};
+
+// ../../node_modules/drizzle-orm/column-builder.js
+var ColumnBuilder = class ColumnBuilder2 {
+  static {
+    __name(this, "ColumnBuilder");
+  }
+  static [entityKind] = "ColumnBuilder";
+  config;
+  constructor(name, dataType, columnType) {
+    this.config = {
+      name,
+      notNull: false,
+      default: void 0,
+      hasDefault: false,
+      primaryKey: false,
+      isUnique: false,
+      uniqueName: void 0,
+      uniqueType: void 0,
+      dataType,
+      columnType,
+      generated: void 0
+    };
+  }
+  /**
+  * Changes the data type of the column. Commonly used with `json` columns. Also, useful for branded types.
+  *
+  * @example
+  * ```ts
+  * const users = pgTable('users', {
+  * 	id: integer('id').$type<UserId>().primaryKey(),
+  * 	details: json('details').$type<UserDetails>().notNull(),
+  * });
+  * ```
+  */
+  $type() {
+    return this;
+  }
+  /**
+  * Adds a `not null` clause to the column definition.
+  *
+  * Affects the `select` model of the table - columns *without* `not null` will be nullable on select.
+  */
+  notNull() {
+    this.config.notNull = true;
+    return this;
+  }
+  /**
+  * Adds a `default <value>` clause to the column definition.
+  *
+  * Affects the `insert` model of the table - columns *with* `default` are optional on insert.
+  *
+  * If you need to set a dynamic default value, use {@link $defaultFn} instead.
+  */
+  default(value) {
+    this.config.default = value;
+    this.config.hasDefault = true;
+    return this;
+  }
+  /**
+  * Adds a dynamic default value to the column.
+  * The function will be called when the row is inserted, and the returned value will be used as the column value.
+  *
+  * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+  */
+  $defaultFn(fn) {
+    this.config.defaultFn = fn;
+    this.config.hasDefault = true;
+    return this;
+  }
+  /**
+  * Alias for {@link $defaultFn}.
+  */
+  $default = this.$defaultFn;
+  /**
+  * Adds a dynamic update value to the column.
+  * The function will be called when the row is updated, and the returned value will be used as the column value if none is provided.
+  * If no `default` (or `$defaultFn`) value is provided, the function will be called when the row is inserted as well, and the returned value will be used as the column value.
+  *
+  * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+  */
+  $onUpdateFn(fn) {
+    this.config.onUpdateFn = fn;
+    this.config.hasDefault = true;
+    return this;
+  }
+  /**
+  * Alias for {@link $onUpdateFn}.
+  */
+  $onUpdate = this.$onUpdateFn;
+  /**
+  * Adds a `primary key` clause to the column definition. This implicitly makes the column `not null`.
+  *
+  * In SQLite, `integer primary key` implicitly makes the column auto-incrementing.
+  */
+  primaryKey() {
+    this.config.primaryKey = true;
+    this.config.notNull = true;
+    return this;
+  }
+};
+
+// ../../node_modules/drizzle-orm/table.js
+var TableName = /* @__PURE__ */ Symbol.for("drizzle:Name");
+var Schema = /* @__PURE__ */ Symbol.for("drizzle:Schema");
+var Columns = /* @__PURE__ */ Symbol.for("drizzle:Columns");
+var ExtraConfigColumns = /* @__PURE__ */ Symbol.for("drizzle:ExtraConfigColumns");
+var OriginalName = /* @__PURE__ */ Symbol.for("drizzle:OriginalName");
+var BaseName = /* @__PURE__ */ Symbol.for("drizzle:BaseName");
+var IsAlias = /* @__PURE__ */ Symbol.for("drizzle:IsAlias");
+var ExtraConfigBuilder = /* @__PURE__ */ Symbol.for("drizzle:ExtraConfigBuilder");
+var IsDrizzleTable = /* @__PURE__ */ Symbol.for("drizzle:IsDrizzleTable");
+var Table = class Table2 {
+  static {
+    __name(this, "Table");
+  }
+  static [entityKind] = "Table";
+  /** @internal */
+  static Symbol = {
+    Name: TableName,
+    Schema,
+    OriginalName,
+    Columns,
+    ExtraConfigColumns,
+    BaseName,
+    IsAlias,
+    ExtraConfigBuilder
+  };
+  /**
+  * @internal
+  * Can be changed if the table is aliased.
+  */
+  [TableName];
+  /**
+  * @internal
+  * Used to store the original name of the table, before any aliasing.
+  */
+  [OriginalName];
+  /** @internal */
+  [Schema];
+  /** @internal */
+  [Columns];
+  /** @internal */
+  [ExtraConfigColumns];
+  /**
+  *  @internal
+  * Used to store the table name before the transformation via the `tableCreator` functions.
+  */
+  [BaseName];
+  /** @internal */
+  [IsAlias] = false;
+  /** @internal */
+  [IsDrizzleTable] = true;
+  /** @internal */
+  [ExtraConfigBuilder] = void 0;
+  constructor(name, schema2, baseName) {
+    this[TableName] = this[OriginalName] = name;
+    this[Schema] = schema2;
+    this[BaseName] = baseName;
+  }
+};
+
+// ../../node_modules/drizzle-orm/pg-core/table.js
+var InlineForeignKeys = /* @__PURE__ */ Symbol.for("drizzle:PgInlineForeignKeys");
+var PgTable = class PgTable2 extends Table {
+  static {
+    __name(this, "PgTable");
+  }
+  static [entityKind] = "PgTable";
+  /** @internal */
+  static Symbol = Object.assign({}, Table.Symbol, {
+    InlineForeignKeys
+  });
+  /**@internal */
+  [InlineForeignKeys] = [];
+  /** @internal */
+  [Table.Symbol.ExtraConfigBuilder] = void 0;
+};
+
+// ../../node_modules/drizzle-orm/pg-core/foreign-keys.js
+var ForeignKeyBuilder = class ForeignKeyBuilder2 {
+  static {
+    __name(this, "ForeignKeyBuilder");
+  }
+  static [entityKind] = "PgForeignKeyBuilder";
+  /** @internal */
+  reference;
+  /** @internal */
+  _onUpdate = "no action";
+  /** @internal */
+  _onDelete = "no action";
+  constructor(config3, actions) {
+    this.reference = () => {
+      const { name, columns, foreignColumns } = config3();
+      return {
+        name,
+        columns,
+        foreignTable: foreignColumns[0].table,
+        foreignColumns
+      };
+    };
+    if (actions) {
+      this._onUpdate = actions.onUpdate;
+      this._onDelete = actions.onDelete;
+    }
+  }
+  onUpdate(action) {
+    this._onUpdate = action === void 0 ? "no action" : action;
+    return this;
+  }
+  onDelete(action) {
+    this._onDelete = action === void 0 ? "no action" : action;
+    return this;
+  }
+  /** @internal */
+  build(table) {
+    return new ForeignKey(table, this);
+  }
+};
+var ForeignKey = class ForeignKey2 {
+  static {
+    __name(this, "ForeignKey");
+  }
+  constructor(table, builder) {
+    this.table = table;
+    this.reference = builder.reference;
+    this.onUpdate = builder._onUpdate;
+    this.onDelete = builder._onDelete;
+  }
+  static [entityKind] = "PgForeignKey";
+  reference;
+  onUpdate;
+  onDelete;
+  getName() {
+    const { name, columns, foreignColumns } = this.reference();
+    const columnNames = columns.map((column) => column.name);
+    const foreignColumnNames = foreignColumns.map((column) => column.name);
+    const chunks = [
+      this.table[PgTable.Symbol.Name],
+      ...columnNames,
+      foreignColumns[0].table[PgTable.Symbol.Name],
+      ...foreignColumnNames
+    ];
+    return name ?? `${chunks.join("_")}_fk`;
+  }
+};
+
+// ../../node_modules/drizzle-orm/tracing-utils.js
+function iife(fn, ...args) {
+  return fn(...args);
+}
+__name(iife, "iife");
+
+// ../../node_modules/drizzle-orm/pg-core/unique-constraint.js
+function uniqueKeyName(table, columns) {
+  return `${table[PgTable.Symbol.Name]}_${columns.join("_")}_unique`;
+}
+__name(uniqueKeyName, "uniqueKeyName");
+var UniqueConstraintBuilder = class UniqueConstraintBuilder2 {
+  static {
+    __name(this, "UniqueConstraintBuilder");
+  }
+  constructor(columns, name) {
+    this.name = name;
+    this.columns = columns;
+  }
+  static [entityKind] = "PgUniqueConstraintBuilder";
+  /** @internal */
+  columns;
+  /** @internal */
+  nullsNotDistinctConfig = false;
+  nullsNotDistinct() {
+    this.nullsNotDistinctConfig = true;
+    return this;
+  }
+  /** @internal */
+  build(table) {
+    return new UniqueConstraint(table, this.columns, this.nullsNotDistinctConfig, this.name);
+  }
+};
+(class UniqueOnConstraintBuilder2 {
+  static {
+    __name(this, "UniqueOnConstraintBuilder");
+  }
+  static [entityKind] = "PgUniqueOnConstraintBuilder";
+  /** @internal */
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+  on(...columns) {
+    return new UniqueConstraintBuilder(columns, this.name);
+  }
+});
+var UniqueConstraint = class UniqueConstraint2 {
+  static {
+    __name(this, "UniqueConstraint");
+  }
+  constructor(table, columns, nullsNotDistinct, name) {
+    this.table = table;
+    this.columns = columns;
+    this.name = name ?? uniqueKeyName(this.table, this.columns.map((column) => column.name));
+    this.nullsNotDistinct = nullsNotDistinct;
+  }
+  static [entityKind] = "PgUniqueConstraint";
+  columns;
+  name;
+  nullsNotDistinct = false;
+  getName() {
+    return this.name;
+  }
+};
+
+// ../../node_modules/drizzle-orm/pg-core/utils/array.js
+function parsePgArrayValue(arrayString, startFrom, inQuotes) {
+  for (let i = startFrom; i < arrayString.length; i++) {
+    const char = arrayString[i];
+    if (char === "\\") {
+      i++;
+      continue;
+    }
+    if (char === '"') {
+      return [
+        arrayString.slice(startFrom, i).replace(/\\/g, ""),
+        i + 1
+      ];
+    }
+    if (inQuotes) {
+      continue;
+    }
+    if (char === "," || char === "}") {
+      return [
+        arrayString.slice(startFrom, i).replace(/\\/g, ""),
+        i
+      ];
+    }
+  }
+  return [
+    arrayString.slice(startFrom).replace(/\\/g, ""),
+    arrayString.length
+  ];
+}
+__name(parsePgArrayValue, "parsePgArrayValue");
+function parsePgNestedArray(arrayString, startFrom = 0) {
+  const result = [];
+  let i = startFrom;
+  let lastCharIsComma = false;
+  while (i < arrayString.length) {
+    const char = arrayString[i];
+    if (char === ",") {
+      if (lastCharIsComma || i === startFrom) {
+        result.push("");
+      }
+      lastCharIsComma = true;
+      i++;
+      continue;
+    }
+    lastCharIsComma = false;
+    if (char === "\\") {
+      i += 2;
+      continue;
+    }
+    if (char === '"') {
+      const [value2, startFrom2] = parsePgArrayValue(arrayString, i + 1, true);
+      result.push(value2);
+      i = startFrom2;
+      continue;
+    }
+    if (char === "}") {
+      return [
+        result,
+        i + 1
+      ];
+    }
+    if (char === "{") {
+      const [value2, startFrom2] = parsePgNestedArray(arrayString, i + 1);
+      result.push(value2);
+      i = startFrom2;
+      continue;
+    }
+    const [value, newStartFrom] = parsePgArrayValue(arrayString, i, false);
+    result.push(value);
+    i = newStartFrom;
+  }
+  return [
+    result,
+    i
+  ];
+}
+__name(parsePgNestedArray, "parsePgNestedArray");
+function parsePgArray(arrayString) {
+  const [result] = parsePgNestedArray(arrayString, 1);
+  return result;
+}
+__name(parsePgArray, "parsePgArray");
+function makePgArray(array) {
+  return `{${array.map((item) => {
+    if (Array.isArray(item)) {
+      return makePgArray(item);
+    }
+    if (typeof item === "string") {
+      return `"${item.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+    }
+    return `${item}`;
+  }).join(",")}}`;
+}
+__name(makePgArray, "makePgArray");
+
+// ../../node_modules/drizzle-orm/pg-core/columns/common.js
+var PgColumnBuilder = class PgColumnBuilder2 extends ColumnBuilder {
+  static {
+    __name(this, "PgColumnBuilder");
+  }
+  foreignKeyConfigs = [];
+  static [entityKind] = "PgColumnBuilder";
+  array(size) {
+    return new PgArrayBuilder(this.config.name, this, size);
+  }
+  references(ref, actions = {}) {
+    this.foreignKeyConfigs.push({
+      ref,
+      actions
+    });
+    return this;
+  }
+  unique(name, config3) {
+    this.config.isUnique = true;
+    this.config.uniqueName = name;
+    this.config.uniqueType = config3?.nulls;
+    return this;
+  }
+  generatedAlwaysAs(as) {
+    this.config.generated = {
+      as,
+      type: "always",
+      mode: "stored"
+    };
+    return this;
+  }
+  /** @internal */
+  buildForeignKeys(column, table) {
+    return this.foreignKeyConfigs.map(({ ref, actions }) => {
+      return iife((ref2, actions2) => {
+        const builder = new ForeignKeyBuilder(() => {
+          const foreignColumn = ref2();
+          return {
+            columns: [
+              column
+            ],
+            foreignColumns: [
+              foreignColumn
+            ]
+          };
+        });
+        if (actions2.onUpdate) {
+          builder.onUpdate(actions2.onUpdate);
+        }
+        if (actions2.onDelete) {
+          builder.onDelete(actions2.onDelete);
+        }
+        return builder.build(table);
+      }, ref, actions);
+    });
+  }
+  /** @internal */
+  buildExtraConfigColumn(table) {
+    return new ExtraConfigColumn(table, this.config);
+  }
+};
+var PgColumn = class PgColumn2 extends Column {
+  static {
+    __name(this, "PgColumn");
+  }
+  constructor(table, config3) {
+    if (!config3.uniqueName) {
+      config3.uniqueName = uniqueKeyName(table, [
+        config3.name
+      ]);
+    }
+    super(table, config3);
+    this.table = table;
+  }
+  static [entityKind] = "PgColumn";
+};
+var ExtraConfigColumn = class ExtraConfigColumn2 extends PgColumn {
+  static {
+    __name(this, "ExtraConfigColumn");
+  }
+  static [entityKind] = "ExtraConfigColumn";
+  getSQLType() {
+    return this.getSQLType();
+  }
+  indexConfig = {
+    order: this.config.order ?? "asc",
+    nulls: this.config.nulls ?? "last",
+    opClass: this.config.opClass
+  };
+  defaultConfig = {
+    order: "asc",
+    nulls: "last",
+    opClass: void 0
+  };
+  asc() {
+    this.indexConfig.order = "asc";
+    return this;
+  }
+  desc() {
+    this.indexConfig.order = "desc";
+    return this;
+  }
+  nullsFirst() {
+    this.indexConfig.nulls = "first";
+    return this;
+  }
+  nullsLast() {
+    this.indexConfig.nulls = "last";
+    return this;
+  }
+  /**
+  * ### PostgreSQL documentation quote
+  *
+  * > An operator class with optional parameters can be specified for each column of an index.
+  * The operator class identifies the operators to be used by the index for that column.
+  * For example, a B-tree index on four-byte integers would use the int4_ops class;
+  * this operator class includes comparison functions for four-byte integers.
+  * In practice the default operator class for the column's data type is usually sufficient.
+  * The main point of having operator classes is that for some data types, there could be more than one meaningful ordering.
+  * For example, we might want to sort a complex-number data type either by absolute value or by real part.
+  * We could do this by defining two operator classes for the data type and then selecting the proper class when creating an index.
+  * More information about operator classes check:
+  *
+  * ### Useful links
+  * https://www.postgresql.org/docs/current/sql-createindex.html
+  *
+  * https://www.postgresql.org/docs/current/indexes-opclass.html
+  *
+  * https://www.postgresql.org/docs/current/xindex.html
+  *
+  * ### Additional types
+  * If you have the `pg_vector` extension installed in your database, you can use the
+  * `vector_l2_ops`, `vector_ip_ops`, `vector_cosine_ops`, `vector_l1_ops`, `bit_hamming_ops`, `bit_jaccard_ops`, `halfvec_l2_ops`, `sparsevec_l2_ops` options, which are predefined types.
+  *
+  * **You can always specify any string you want in the operator class, in case Drizzle doesn't have it natively in its types**
+  *
+  * @param opClass
+  * @returns
+  */
+  op(opClass) {
+    this.indexConfig.opClass = opClass;
+    return this;
+  }
+};
+(class IndexedColumn2 {
+  static {
+    __name(this, "IndexedColumn");
+  }
+  static [entityKind] = "IndexedColumn";
+  constructor(name, type, indexConfig) {
+    this.name = name;
+    this.type = type;
+    this.indexConfig = indexConfig;
+  }
+  name;
+  type;
+  indexConfig;
+});
+var PgArrayBuilder = class PgArrayBuilder2 extends PgColumnBuilder {
+  static {
+    __name(this, "PgArrayBuilder");
+  }
+  static [entityKind] = "PgArrayBuilder";
+  constructor(name, baseBuilder, size) {
+    super(name, "array", "PgArray");
+    this.config.baseBuilder = baseBuilder;
+    this.config.size = size;
+  }
+  /** @internal */
+  build(table) {
+    const baseColumn = this.config.baseBuilder.build(table);
+    return new PgArray(table, this.config, baseColumn);
+  }
+};
+var PgArray = class PgArray2 extends PgColumn {
+  static {
+    __name(this, "PgArray");
+  }
+  constructor(table, config3, baseColumn, range) {
+    super(table, config3);
+    this.baseColumn = baseColumn;
+    this.range = range;
+    this.size = config3.size;
+  }
+  size;
+  static [entityKind] = "PgArray";
+  getSQLType() {
+    return `${this.baseColumn.getSQLType()}[${typeof this.size === "number" ? this.size : ""}]`;
+  }
+  mapFromDriverValue(value) {
+    if (typeof value === "string") {
+      value = parsePgArray(value);
+    }
+    return value.map((v) => this.baseColumn.mapFromDriverValue(v));
+  }
+  mapToDriverValue(value, isNestedArray = false) {
+    const a = value.map((v) => v === null ? null : is(this.baseColumn, PgArray2) ? this.baseColumn.mapToDriverValue(v, true) : this.baseColumn.mapToDriverValue(v));
+    if (isNestedArray) return a;
+    return makePgArray(a);
+  }
+};
+
+// ../../node_modules/drizzle-orm/pg-core/columns/enum.js
+var isPgEnumSym = /* @__PURE__ */ Symbol.for("drizzle:isPgEnum");
+function isPgEnum(obj) {
+  return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
+}
+__name(isPgEnum, "isPgEnum");
+(class PgEnumColumnBuilder2 extends PgColumnBuilder {
+  static {
+    __name(this, "PgEnumColumnBuilder");
+  }
+  static [entityKind] = "PgEnumColumnBuilder";
+  constructor(name, enumInstance) {
+    super(name, "string", "PgEnumColumn");
+    this.config.enum = enumInstance;
+  }
+  /** @internal */
+  build(table) {
+    return new PgEnumColumn(table, this.config);
+  }
+});
+var PgEnumColumn = class PgEnumColumn2 extends PgColumn {
+  static {
+    __name(this, "PgEnumColumn");
+  }
+  static [entityKind] = "PgEnumColumn";
+  enum = this.config.enum;
+  enumValues = this.config.enum.enumValues;
+  constructor(table, config3) {
+    super(table, config3);
+    this.enum = config3.enum;
+  }
+  getSQLType() {
+    return this.enum.enumName;
+  }
+};
+
+// ../../node_modules/drizzle-orm/subquery.js
+var Subquery = class Subquery2 {
+  static {
+    __name(this, "Subquery");
+  }
+  static [entityKind] = "Subquery";
+  constructor(sql2, selection, alias, isWith = false) {
+    this._ = {
+      brand: "Subquery",
+      sql: sql2,
+      selectedFields: selection,
+      alias,
+      isWith
+    };
+  }
+};
+(class WithSubquery2 extends Subquery {
+  static {
+    __name(this, "WithSubquery");
+  }
+  static [entityKind] = "WithSubquery";
+});
+var tracer = {
+  startActiveSpan(name, fn) {
+    {
+      return fn();
+    }
+  }
+};
+
+// ../../node_modules/drizzle-orm/view-common.js
+var ViewBaseConfig = /* @__PURE__ */ Symbol.for("drizzle:ViewBaseConfig");
+
+// ../../node_modules/drizzle-orm/sql/sql.js
+(class FakePrimitiveParam2 {
+  static {
+    __name(this, "FakePrimitiveParam");
+  }
+  static [entityKind] = "FakePrimitiveParam";
+});
+function isSQLWrapper(value) {
+  return value !== null && value !== void 0 && typeof value.getSQL === "function";
+}
+__name(isSQLWrapper, "isSQLWrapper");
+function mergeQueries(queries) {
+  const result = {
+    sql: "",
+    params: []
+  };
+  for (const query of queries) {
+    result.sql += query.sql;
+    result.params.push(...query.params);
+    if (query.typings?.length) {
+      if (!result.typings) {
+        result.typings = [];
+      }
+      result.typings.push(...query.typings);
+    }
+  }
+  return result;
+}
+__name(mergeQueries, "mergeQueries");
+var StringChunk = class StringChunk2 {
+  static {
+    __name(this, "StringChunk");
+  }
+  static [entityKind] = "StringChunk";
+  value;
+  constructor(value) {
+    this.value = Array.isArray(value) ? value : [
+      value
+    ];
+  }
+  getSQL() {
+    return new SQL([
+      this
+    ]);
+  }
+};
+var SQL = class SQL2 {
+  static {
+    __name(this, "SQL");
+  }
+  constructor(queryChunks) {
+    this.queryChunks = queryChunks;
+  }
+  static [entityKind] = "SQL";
+  /** @internal */
+  decoder = noopDecoder;
+  shouldInlineParams = false;
+  append(query) {
+    this.queryChunks.push(...query.queryChunks);
+    return this;
+  }
+  toQuery(config3) {
+    return tracer.startActiveSpan("drizzle.buildSQL", (span) => {
+      const query = this.buildQueryFromSourceParams(this.queryChunks, config3);
+      span?.setAttributes({
+        "drizzle.query.text": query.sql,
+        "drizzle.query.params": JSON.stringify(query.params)
+      });
+      return query;
+    });
+  }
+  buildQueryFromSourceParams(chunks, _config) {
+    const config3 = Object.assign({}, _config, {
+      inlineParams: _config.inlineParams || this.shouldInlineParams,
+      paramStartIndex: _config.paramStartIndex || {
+        value: 0
+      }
+    });
+    const { escapeName, escapeParam, prepareTyping, inlineParams, paramStartIndex } = config3;
+    return mergeQueries(chunks.map((chunk) => {
+      if (is(chunk, StringChunk)) {
+        return {
+          sql: chunk.value.join(""),
+          params: []
+        };
+      }
+      if (is(chunk, Name)) {
+        return {
+          sql: escapeName(chunk.value),
+          params: []
+        };
+      }
+      if (chunk === void 0) {
+        return {
+          sql: "",
+          params: []
+        };
+      }
+      if (Array.isArray(chunk)) {
+        const result = [
+          new StringChunk("(")
+        ];
+        for (const [i, p] of chunk.entries()) {
+          result.push(p);
+          if (i < chunk.length - 1) {
+            result.push(new StringChunk(", "));
+          }
+        }
+        result.push(new StringChunk(")"));
+        return this.buildQueryFromSourceParams(result, config3);
+      }
+      if (is(chunk, SQL2)) {
+        return this.buildQueryFromSourceParams(chunk.queryChunks, {
+          ...config3,
+          inlineParams: inlineParams || chunk.shouldInlineParams
+        });
+      }
+      if (is(chunk, Table)) {
+        const schemaName = chunk[Table.Symbol.Schema];
+        const tableName = chunk[Table.Symbol.Name];
+        return {
+          sql: schemaName === void 0 ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
+          params: []
+        };
+      }
+      if (is(chunk, Column)) {
+        if (_config.invokeSource === "indexes") {
+          return {
+            sql: escapeName(chunk.name),
+            params: []
+          };
+        }
+        return {
+          sql: escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(chunk.name),
+          params: []
+        };
+      }
+      if (is(chunk, View)) {
+        const schemaName = chunk[ViewBaseConfig].schema;
+        const viewName = chunk[ViewBaseConfig].name;
+        return {
+          sql: schemaName === void 0 ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
+          params: []
+        };
+      }
+      if (is(chunk, Param)) {
+        if (is(chunk.value, Placeholder)) {
+          return {
+            sql: escapeParam(paramStartIndex.value++, chunk),
+            params: [
+              chunk
+            ],
+            typings: [
+              "none"
+            ]
+          };
+        }
+        const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
+        if (is(mappedValue, SQL2)) {
+          return this.buildQueryFromSourceParams([
+            mappedValue
+          ], config3);
+        }
+        if (inlineParams) {
+          return {
+            sql: this.mapInlineParam(mappedValue, config3),
+            params: []
+          };
+        }
+        let typings = [
+          "none"
+        ];
+        if (prepareTyping) {
+          typings = [
+            prepareTyping(chunk.encoder)
+          ];
+        }
+        return {
+          sql: escapeParam(paramStartIndex.value++, mappedValue),
+          params: [
+            mappedValue
+          ],
+          typings
+        };
+      }
+      if (is(chunk, Placeholder)) {
+        return {
+          sql: escapeParam(paramStartIndex.value++, chunk),
+          params: [
+            chunk
+          ],
+          typings: [
+            "none"
+          ]
+        };
+      }
+      if (is(chunk, SQL2.Aliased) && chunk.fieldAlias !== void 0) {
+        return {
+          sql: escapeName(chunk.fieldAlias),
+          params: []
+        };
+      }
+      if (is(chunk, Subquery)) {
+        if (chunk._.isWith) {
+          return {
+            sql: escapeName(chunk._.alias),
+            params: []
+          };
+        }
+        return this.buildQueryFromSourceParams([
+          new StringChunk("("),
+          chunk._.sql,
+          new StringChunk(") "),
+          new Name(chunk._.alias)
+        ], config3);
+      }
+      if (isPgEnum(chunk)) {
+        if (chunk.schema) {
+          return {
+            sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName),
+            params: []
+          };
+        }
+        return {
+          sql: escapeName(chunk.enumName),
+          params: []
+        };
+      }
+      if (isSQLWrapper(chunk)) {
+        if (chunk.shouldOmitSQLParens?.()) {
+          return this.buildQueryFromSourceParams([
+            chunk.getSQL()
+          ], config3);
+        }
+        return this.buildQueryFromSourceParams([
+          new StringChunk("("),
+          chunk.getSQL(),
+          new StringChunk(")")
+        ], config3);
+      }
+      if (inlineParams) {
+        return {
+          sql: this.mapInlineParam(chunk, config3),
+          params: []
+        };
+      }
+      return {
+        sql: escapeParam(paramStartIndex.value++, chunk),
+        params: [
+          chunk
+        ],
+        typings: [
+          "none"
+        ]
+      };
+    }));
+  }
+  mapInlineParam(chunk, { escapeString }) {
+    if (chunk === null) {
+      return "null";
+    }
+    if (typeof chunk === "number" || typeof chunk === "boolean") {
+      return chunk.toString();
+    }
+    if (typeof chunk === "string") {
+      return escapeString(chunk);
+    }
+    if (typeof chunk === "object") {
+      const mappedValueAsString = chunk.toString();
+      if (mappedValueAsString === "[object Object]") {
+        return escapeString(JSON.stringify(chunk));
+      }
+      return escapeString(mappedValueAsString);
+    }
+    throw new Error("Unexpected param value: " + chunk);
+  }
+  getSQL() {
+    return this;
+  }
+  as(alias) {
+    if (alias === void 0) {
+      return this;
+    }
+    return new SQL2.Aliased(this, alias);
+  }
+  mapWith(decoder) {
+    this.decoder = typeof decoder === "function" ? {
+      mapFromDriverValue: decoder
+    } : decoder;
+    return this;
+  }
+  inlineParams() {
+    this.shouldInlineParams = true;
+    return this;
+  }
+  /**
+  * This method is used to conditionally include a part of the query.
+  *
+  * @param condition - Condition to check
+  * @returns itself if the condition is `true`, otherwise `undefined`
+  */
+  if(condition) {
+    return condition ? this : void 0;
+  }
+};
+var Name = class Name2 {
+  static {
+    __name(this, "Name");
+  }
+  constructor(value) {
+    this.value = value;
+  }
+  static [entityKind] = "Name";
+  brand;
+  getSQL() {
+    return new SQL([
+      this
+    ]);
+  }
+};
+function isDriverValueEncoder(value) {
+  return typeof value === "object" && value !== null && "mapToDriverValue" in value && typeof value.mapToDriverValue === "function";
+}
+__name(isDriverValueEncoder, "isDriverValueEncoder");
+var noopDecoder = {
+  mapFromDriverValue: /* @__PURE__ */ __name((value) => value, "mapFromDriverValue")
+};
+var noopEncoder = {
+  mapToDriverValue: /* @__PURE__ */ __name((value) => value, "mapToDriverValue")
+};
+({
+  ...noopDecoder,
+  ...noopEncoder
+});
+var Param = class Param2 {
+  static {
+    __name(this, "Param");
+  }
+  /**
+  * @param value - Parameter value
+  * @param encoder - Encoder to convert the value to a driver parameter
+  */
+  constructor(value, encoder = noopEncoder) {
+    this.value = value;
+    this.encoder = encoder;
+  }
+  static [entityKind] = "Param";
+  brand;
+  getSQL() {
+    return new SQL([
+      this
+    ]);
+  }
+};
+function sql(strings, ...params) {
+  const queryChunks = [];
+  if (params.length > 0 || strings.length > 0 && strings[0] !== "") {
+    queryChunks.push(new StringChunk(strings[0]));
+  }
+  for (const [paramIndex, param2] of params.entries()) {
+    queryChunks.push(param2, new StringChunk(strings[paramIndex + 1]));
+  }
+  return new SQL(queryChunks);
+}
+__name(sql, "sql");
+((sql2) => {
+  function empty() {
+    return new SQL([]);
+  }
+  __name(empty, "empty");
+  sql2.empty = empty;
+  function fromList(list) {
+    return new SQL(list);
+  }
+  __name(fromList, "fromList");
+  sql2.fromList = fromList;
+  function raw(str) {
+    return new SQL([
+      new StringChunk(str)
+    ]);
+  }
+  __name(raw, "raw");
+  sql2.raw = raw;
+  function join(chunks, separator) {
+    const result = [];
+    for (const [i, chunk] of chunks.entries()) {
+      if (i > 0 && separator !== void 0) {
+        result.push(separator);
+      }
+      result.push(chunk);
+    }
+    return new SQL(result);
+  }
+  __name(join, "join");
+  sql2.join = join;
+  function identifier(value) {
+    return new Name(value);
+  }
+  __name(identifier, "identifier");
+  sql2.identifier = identifier;
+  function placeholder2(name2) {
+    return new Placeholder(name2);
+  }
+  __name(placeholder2, "placeholder2");
+  sql2.placeholder = placeholder2;
+  function param2(value, encoder) {
+    return new Param(value, encoder);
+  }
+  __name(param2, "param2");
+  sql2.param = param2;
+})(sql || (sql = {}));
+((SQL22) => {
+  let Aliased = class Aliased2 {
+    static {
+      __name(this, "Aliased");
+    }
+    constructor(sql2, fieldAlias) {
+      this.sql = sql2;
+      this.fieldAlias = fieldAlias;
+    }
+    static [entityKind] = "SQL.Aliased";
+    /** @internal */
+    isSelectionField = false;
+    getSQL() {
+      return this.sql;
+    }
+    /** @internal */
+    clone() {
+      return new Aliased2(this.sql, this.fieldAlias);
+    }
+  };
+  SQL22.Aliased = Aliased;
+})(SQL || (SQL = {}));
+var Placeholder = class Placeholder2 {
+  static {
+    __name(this, "Placeholder");
+  }
+  constructor(name2) {
+    this.name = name2;
+  }
+  static [entityKind] = "Placeholder";
+  getSQL() {
+    return new SQL([
+      this
+    ]);
+  }
+};
+var View = class View2 {
+  static {
+    __name(this, "View");
+  }
+  static [entityKind] = "View";
+  /** @internal */
+  [ViewBaseConfig];
+  constructor({ name: name2, schema: schema2, selectedFields, query }) {
+    this[ViewBaseConfig] = {
+      name: name2,
+      originalName: name2,
+      schema: schema2,
+      selectedFields,
+      query,
+      isExisting: !query,
+      isAlias: false
+    };
+  }
+  getSQL() {
+    return new SQL([
+      this
+    ]);
+  }
+};
+Column.prototype.getSQL = function() {
+  return new SQL([
+    this
+  ]);
+};
+Table.prototype.getSQL = function() {
+  return new SQL([
+    this
+  ]);
+};
+Subquery.prototype.getSQL = function() {
+  return new SQL([
+    this
+  ]);
+};
+
+// ../../node_modules/drizzle-orm/sql/expressions/conditions.js
+function bindIfParam(value, column) {
+  if (isDriverValueEncoder(column) && !isSQLWrapper(value) && !is(value, Param) && !is(value, Placeholder) && !is(value, Column) && !is(value, Table) && !is(value, View)) {
+    return new Param(value, column);
+  }
+  return value;
+}
+__name(bindIfParam, "bindIfParam");
+var eq = /* @__PURE__ */ __name((left, right) => {
+  return sql`${left} = ${bindIfParam(right, left)}`;
+}, "eq");
+function and(...unfilteredConditions) {
+  const conditions = unfilteredConditions.filter((c) => c !== void 0);
+  if (conditions.length === 0) {
+    return void 0;
+  }
+  if (conditions.length === 1) {
+    return new SQL(conditions);
+  }
+  return new SQL([
+    new StringChunk("("),
+    sql.join(conditions, new StringChunk(" and ")),
+    new StringChunk(")")
+  ]);
+}
+__name(and, "and");
+function isNull(value) {
+  return sql`${value} is null`;
+}
+__name(isNull, "isNull");
+
+// ../../packages/dvss-integration-libs/src/integration-common-utils/dao/integration-configuration.dao.ts
+function _ts_decorate11(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate11, "_ts_decorate");
+function _ts_metadata8(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata8, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+exports.IntegrationConfigurationDao = class IntegrationConfigurationDao {
+  static {
+    __name(this, "IntegrationConfigurationDao");
+  }
+  conn;
+  logger;
+  fileName = "integration-configuration.dao";
+  constructor(conn, logger) {
+    this.conn = conn;
+    this.logger = logger;
+  }
+  async addCapabilityIntegration(input, loggedInUserId) {
+    this.logger.info(loggedInUserId, this.addCapabilityIntegration.name, this.fileName, `CapabilityDaoService -> addCapabilityIntegration called`);
+    try {
+      return this.conn.transaction(async (tx) => {
+        const [integrationResult] = await tx.insert(dvssBackendModuleDatastore.schema.capabilityIntegration).values(input).$returningId();
+        if (!integrationResult.id) {
+          tx.rollback();
+          return;
+        }
+        if (input.configuredFor) {
+          const insertData = {
+            capabilityIntegrationId: integrationResult.id,
+            configuredForId: input.configuredFor.configuredForId,
+            configuredForType: input.configuredFor.configuredForType,
+            status: capabilityIntegration_model.CAPABILITY_INTEGRATION_STATUS_ENUM.ACTIVE,
+            projectId: input.projectId,
+            createdAt: /* @__PURE__ */ new Date(),
+            createdBy: loggedInUserId
+          };
+          await tx.insert(dvssBackendModuleDatastore.schema.capIntegResourceMapping).values(insertData);
+        }
+        return {
+          id: integrationResult.id
+        };
+      });
+    } catch (error) {
+      this.logger.error(loggedInUserId, this.addCapabilityIntegration.name, this.fileName, "Error in addCapabilityIntegration", error, input);
+      throw error;
+    }
+  }
+  /**
+  * Get capability by id (for add-capability-integration validation).
+  * Copied from project-ms CapabilityDaoService.getCapability.
+  */
+  async getCapability(request, loggedInUserId) {
+    try {
+      this.logger.info(loggedInUserId, this.getCapability.name, this.fileName, "getCapability called", {
+        request
+      });
+      return await this.conn.query.capability.findFirst({
+        where: and(eq(dvssBackendModuleDatastore.schema.capability.id, request.capabilityId), isNull(dvssBackendModuleDatastore.schema.capability.deletedAt))
+      });
+    } catch (error) {
+      this.logger.error(loggedInUserId, this.getCapability.name, this.fileName, "Error on getCapability", error, {
+        request
+      });
+      throw error;
+    }
+  }
+  /**
+  * Get capability provider by id (for add-capability-integration validation).
+  * Copied from project-ms CapabilityProviderDao.getCapabilityProvider.
+  */
+  async getCapabilityProvider(request, loggedInUserId) {
+    try {
+      this.logger.info(loggedInUserId, this.getCapabilityProvider.name, this.fileName, "getCapabilityProvider called", {
+        request
+      });
+      return await this.conn.query.capabilityProvider.findFirst({
+        where: and(eq(dvssBackendModuleDatastore.schema.capabilityProvider.id, request.capabilityProviderId), isNull(dvssBackendModuleDatastore.schema.capabilityProvider.deletedAt))
+      });
+    } catch (error) {
+      this.logger.error(loggedInUserId, this.getCapabilityProvider.name, this.fileName, "Error on getCapabilityProvider", error, {
+        request
+      });
+      throw error;
+    }
+  }
+  /**
+  * Updates capability integration in the database.
+  * Copied from project-ms CapabilityIntegrationDao.updateCapabilityIntegration.
+  *
+  * @param input - Object containing the integration ID and update data
+  * @param loggedInUserId - User ID for logging
+  * @returns Promise that resolves to the update operation status
+  */
+  async updateCapabilityIntegration(input, loggedInUserId) {
+    try {
+      this.logger.info(loggedInUserId, this.updateCapabilityIntegration.name, this.fileName, "Updating capability integration");
+      const response = await this.conn.update(dvssBackendModuleDatastore.schema.capabilityIntegration).set({
+        ...input.updateData
+      }).where(eq(dvssBackendModuleDatastore.schema.capabilityIntegration.id, input.id));
+      return {
+        status: response[0].affectedRows > 0
+      };
+    } catch (error) {
+      this.logger.error(loggedInUserId, this.updateCapabilityIntegration.name, this.fileName, "Error updating capability integration", error);
+      throw error;
+    }
+  }
+  /**
+  * Get capability integration by id (for parent validation when parentId is set).
+  * Copied from project-ms CapabilityIntegrationDao.getCapabilityIntegration.
+  */
+  async getCapabilityIntegration(input, loggedInUserId) {
+    try {
+      this.logger.info(loggedInUserId, this.getCapabilityIntegration.name, this.fileName, "getCapabilityIntegration called", input);
+      return await this.conn.query.capabilityIntegration.findFirst({
+        where: and(isNull(dvssBackendModuleDatastore.schema.capabilityIntegration.deletedAt), eq(dvssBackendModuleDatastore.schema.capabilityIntegration.id, input.capabilityIntegrationId))
+      });
+    } catch (error) {
+      this.logger.error(loggedInUserId, this.getCapabilityIntegration.name, this.fileName, "Error on getCapabilityIntegration", error, input);
+      throw error;
+    }
+  }
+};
+exports.IntegrationConfigurationDao = _ts_decorate11([
+  common.Injectable(),
+  _ts_param(0, common.Inject(dvssBackendModuleDatastore.appConstants.DB_CONNECTION)),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof MySql2Database === "undefined" ? Object : MySql2Database,
+    typeof dvssBackendModuleUtility.LoggerService === "undefined" ? Object : dvssBackendModuleUtility.LoggerService
+  ])
+], exports.IntegrationConfigurationDao);
+function _ts_decorate12(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate12, "_ts_decorate");
+function _ts_metadata9(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata9, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+exports.IntegrationUserManagementDao = class IntegrationUserManagementDao {
   static {
-    __name(this, "BaseMembershipCustomerManagement");
+    __name(this, "IntegrationUserManagementDao");
   }
-};
-
-// ../../packages/dvss-integration-libs/src/integration-operation-skeletons/capabilities/membership/subcapabilities/membership-management.base.ts
-var BaseMembershipManagement = class {
-  static {
-    __name(this, "BaseMembershipManagement");
+  conn;
+  constructor(conn) {
+    this.conn = conn;
   }
 };
-
-// ../../packages/dvss-integration-libs/src/integration-common-utils/models/credit-management.model.ts
-var CREDIT_TYPE_ENUM = /* @__PURE__ */ (function(CREDIT_TYPE_ENUM2) {
-  CREDIT_TYPE_ENUM2["COUPON"] = "COUPON";
-  CREDIT_TYPE_ENUM2["AMOUNT"] = "AMOUNT";
-  return CREDIT_TYPE_ENUM2;
-})({});
-var CREDIT_STATUS_ENUM = /* @__PURE__ */ (function(CREDIT_STATUS_ENUM2) {
-  CREDIT_STATUS_ENUM2["ACTIVE"] = "ACTIVE";
-  CREDIT_STATUS_ENUM2["REDEEMED"] = "REDEEMED";
-  CREDIT_STATUS_ENUM2["EXPIRED"] = "EXPIRED";
-  CREDIT_STATUS_ENUM2["REVOKED"] = "REVOKED";
-  return CREDIT_STATUS_ENUM2;
-})({});
-var CREDIT_FILTER_BY_ENUM = /* @__PURE__ */ (function(CREDIT_FILTER_BY_ENUM2) {
-  CREDIT_FILTER_BY_ENUM2["TYPE"] = "TYPE";
-  CREDIT_FILTER_BY_ENUM2["STATUS"] = "STATUS";
-  return CREDIT_FILTER_BY_ENUM2;
-})({});
-
-// ../../packages/dvss-integration-libs/src/integration-common-utils/models/capability-integration.model.ts
-var INTEGRATION_PROVIDER_ENUM = /* @__PURE__ */ (function(INTEGRATION_PROVIDER_ENUM2) {
-  INTEGRATION_PROVIDER_ENUM2["TRYBE"] = "TRYBE";
-  return INTEGRATION_PROVIDER_ENUM2;
-})({});
-
-// ../../packages/dvss-integration-libs/src/integration-common-utils/models/wellness-management.model.ts
-var BOOKABLE_ITEM_TYPE_ENUM = /* @__PURE__ */ (function(BOOKABLE_ITEM_TYPE_ENUM2) {
-  BOOKABLE_ITEM_TYPE_ENUM2["APPOINTMENT"] = "APPOINTMENT";
-  BOOKABLE_ITEM_TYPE_ENUM2["SESSION"] = "SESSION";
-  BOOKABLE_ITEM_TYPE_ENUM2["COURSE"] = "COURSE";
-  return BOOKABLE_ITEM_TYPE_ENUM2;
-})({});
-var BOOKABLE_ITEM_STATUS_ENUM = /* @__PURE__ */ (function(BOOKABLE_ITEM_STATUS_ENUM2) {
-  BOOKABLE_ITEM_STATUS_ENUM2["ACTIVE"] = "ACTIVE";
-  BOOKABLE_ITEM_STATUS_ENUM2["INACTIVE"] = "INACTIVE";
-  return BOOKABLE_ITEM_STATUS_ENUM2;
-})({});
-var DAY_OF_WEEK = /* @__PURE__ */ (function(DAY_OF_WEEK2) {
-  DAY_OF_WEEK2["MON"] = "MON";
-  DAY_OF_WEEK2["TUE"] = "TUE";
-  DAY_OF_WEEK2["WED"] = "WED";
-  DAY_OF_WEEK2["THU"] = "THU";
-  DAY_OF_WEEK2["FRI"] = "FRI";
-  DAY_OF_WEEK2["SAT"] = "SAT";
-  DAY_OF_WEEK2["SUN"] = "SUN";
-  return DAY_OF_WEEK2;
-})({});
-function _ts_decorate11(decorators, target, key, desc) {
+exports.IntegrationUserManagementDao = _ts_decorate12([
+  common.Injectable(),
+  _ts_param2(0, common.Inject(dvssBackendModuleDatastore.appConstants.DB_CONNECTION)),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
+    typeof MySql2Database === "undefined" ? Object : MySql2Database
+  ])
+], exports.IntegrationUserManagementDao);
+function _ts_decorate13(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate11, "_ts_decorate");
-function _ts_metadata8(k, v) {
+__name(_ts_decorate13, "_ts_decorate");
+function _ts_metadata10(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata8, "_ts_metadata");
+__name(_ts_metadata10, "_ts_metadata");
 exports.TrybeCustomerManagement = class _TrybeCustomerManagement {
   static {
     __name(this, "TrybeCustomerManagement");
@@ -788,13 +2329,22 @@ exports.TrybeCustomerManagement = class _TrybeCustomerManagement {
     this.trafficGatewayService = trafficGatewayService;
   }
   /**
-  * Abstract method to create a new customer
-  * Must be implemented by concrete classes
+  * Create a new customer on Trybe (POST /customers/customers).
   *
-  * @returns Promise resolving when the customer is created
+  * @returns Promise resolving to the created customer
   */
-  createCustomer() {
-    throw new Error("createCustomer not yet implemented");
+  async createCustomer(request, integration, loggedInUserId) {
+    this.logger.info(loggedInUserId, this.createCustomer.name, this.fileName, `${_TrybeCustomerManagement.name} -> ${this.createCustomer.name} Called`, {
+      request
+    });
+    const response = await this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.POST,
+      url: "/customers/customers",
+      baseUrl: integration.config.platformConfig.baseUrl,
+      headers: integration.headers,
+      body: request
+    }, integration, loggedInUserId);
+    return response.data;
   }
   /**
   * Abstract method to search for wellness customers
@@ -835,34 +2385,44 @@ exports.TrybeCustomerManagement = class _TrybeCustomerManagement {
     }
   }
   /**
-  * Abstract method to update an existing customer
-  * Must be implemented by concrete classes
+  * Update an existing customer on Trybe (PUT /customers/customers/:id), then fetch and return full customer.
   *
-  * @returns Promise resolving when the customer is updated
+  * @returns Promise resolving to the updated customer
   */
-  updateCustomer() {
-    throw new Error("updateCustomer not yet implemented");
+  async updateCustomer(customerId, request, integration, loggedInUserId) {
+    this.logger.info(loggedInUserId, this.updateCustomer.name, this.fileName, `${_TrybeCustomerManagement.name} -> ${this.updateCustomer.name} Called`, {
+      customerId,
+      request
+    });
+    const response = await this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.PUT,
+      url: `/customers/customers/${customerId}`,
+      baseUrl: integration.config.platformConfig.baseUrl,
+      headers: integration.headers,
+      body: request
+    }, integration, loggedInUserId);
+    return response.data;
   }
 };
-exports.TrybeCustomerManagement = _ts_decorate11([
+exports.TrybeCustomerManagement = _ts_decorate13([
   common.Injectable(),
-  _ts_metadata8("design:type", Function),
-  _ts_metadata8("design:paramtypes", [
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
     typeof dvssBackendModuleUtility.LoggerService === "undefined" ? Object : dvssBackendModuleUtility.LoggerService,
     typeof exports.TrafficGatewayService === "undefined" ? Object : exports.TrafficGatewayService
   ])
 ], exports.TrybeCustomerManagement);
-function _ts_decorate12(decorators, target, key, desc) {
+function _ts_decorate14(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate12, "_ts_decorate");
-function _ts_metadata9(k, v) {
+__name(_ts_decorate14, "_ts_decorate");
+function _ts_metadata11(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata9, "_ts_metadata");
+__name(_ts_metadata11, "_ts_metadata");
 exports.TrybeAuthService = class _TrybeAuthService {
   static {
     __name(this, "TrybeAuthService");
@@ -911,6 +2471,9 @@ exports.TrybeAuthService = class _TrybeAuthService {
       if (!platformConfig.baseUrl) {
         throw new Error("Platform configuration is invalid: Base URL not found");
       }
+      if (!this.isValidUrl(platformConfig.baseUrl)) {
+        throw new Error("Platform configuration is invalid: Base URL is not a valid URL");
+      }
     } else {
       throw new Error("Platform configuration is invalid: Platform config is empty");
     }
@@ -922,6 +2485,14 @@ exports.TrybeAuthService = class _TrybeAuthService {
       headers
     };
   }
+  isValidUrl(urlString) {
+    try {
+      const url = new URL(urlString);
+      return url.protocol === "http:" || url.protocol === "https:";
+    } catch {
+      return false;
+    }
+  }
   /**
   * Tests Trybe integration by making a test API call
   * Uses a test customer lookup to verify credentials are valid
@@ -956,10 +2527,10 @@ exports.TrybeAuthService = class _TrybeAuthService {
     throw new Error("Method not implemented.");
   }
 };
-exports.TrybeAuthService = _ts_decorate12([
+exports.TrybeAuthService = _ts_decorate14([
   common.Injectable(),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", [
     typeof exports.TrybeCustomerManagement === "undefined" ? Object : exports.TrybeCustomerManagement,
     typeof dvssBackendModuleUtility.LoggerService === "undefined" ? Object : dvssBackendModuleUtility.LoggerService
   ])
@@ -976,7 +2547,7 @@ __name(mapStatus, "mapStatus");
 function mapTrybeCreditsToSystem(res, integration) {
   const groups = /* @__PURE__ */ new Map();
   for (const t of res.data) {
-    const key = `${t.coupon_name}|${t.issued_at}`;
+    const key = `${t.coupon_name}|${t.expires_at.split("T")[0]}`;
     const list = groups.get(key) ?? [];
     list.push(t);
     groups.set(key, list);
@@ -1022,17 +2593,17 @@ function mapTrybeCreditsToSystem(res, integration) {
 __name(mapTrybeCreditsToSystem, "mapTrybeCreditsToSystem");
 
 // ../../packages/dvss-integration-trybe/src/capabilities/credit-management/credit-booking.service.ts
-function _ts_decorate13(decorators, target, key, desc) {
+function _ts_decorate15(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate13, "_ts_decorate");
-function _ts_metadata10(k, v) {
+__name(_ts_decorate15, "_ts_decorate");
+function _ts_metadata12(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata10, "_ts_metadata");
+__name(_ts_metadata12, "_ts_metadata");
 exports.TrybeCreditBooking = class _TrybeCreditBooking {
   static {
     __name(this, "TrybeCreditBooking");
@@ -1090,10 +2661,10 @@ exports.TrybeCreditBooking = class _TrybeCreditBooking {
     return mapTrybeCreditsToSystem(raw, validatedIntegration);
   }
 };
-exports.TrybeCreditBooking = _ts_decorate13([
+exports.TrybeCreditBooking = _ts_decorate15([
   common.Injectable(),
-  _ts_metadata10("design:type", Function),
-  _ts_metadata10("design:paramtypes", [
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
     typeof dvssBackendModuleUtility.LoggerService === "undefined" ? Object : dvssBackendModuleUtility.LoggerService,
     typeof exports.TrafficGatewayService === "undefined" ? Object : exports.TrafficGatewayService,
     typeof exports.TrybeAuthService === "undefined" ? Object : exports.TrybeAuthService
@@ -1160,16 +2731,19 @@ var TRYBE_OFFERING_TYPE_ENUM = /* @__PURE__ */ (function(TRYBE_OFFERING_TYPE_ENU
   TRYBE_OFFERING_TYPE_ENUM2["COURSE"] = "COURSE";
   return TRYBE_OFFERING_TYPE_ENUM2;
 })({});
-
-// ../../packages/dvss-integration-trybe/src/capabilities/wellness/wellness-management.mapper.ts
+var TRYBE_OFFERING_TYPE_API = {
+  APPOINTMENT: "appointment",
+  SESSION: "session",
+  COURSE: "course"
+};
 var TRYBE_WEEKDAYS_MAPPING = {
-  monday: DAY_OF_WEEK.MON,
-  tuesday: DAY_OF_WEEK.TUE,
-  wednesday: DAY_OF_WEEK.WED,
-  thursday: DAY_OF_WEEK.THU,
-  friday: DAY_OF_WEEK.FRI,
-  saturday: DAY_OF_WEEK.SAT,
-  sunday: DAY_OF_WEEK.SUN
+  monday: models.DAY_OF_WEEK.MON,
+  tuesday: models.DAY_OF_WEEK.TUE,
+  wednesday: models.DAY_OF_WEEK.WED,
+  thursday: models.DAY_OF_WEEK.THU,
+  friday: models.DAY_OF_WEEK.FRI,
+  saturday: models.DAY_OF_WEEK.SAT,
+  sunday: models.DAY_OF_WEEK.SUN
 };
 function mapTrybeImageToMedia(image) {
   if (!image) return void 0;
@@ -1387,6 +2961,32 @@ function mapTrybeCategoryToBookableItemCategory(category, index) {
   };
 }
 __name(mapTrybeCategoryToBookableItemCategory, "mapTrybeCategoryToBookableItemCategory");
+function mapTrybePractitionerToOfferingResource(practitioner, index) {
+  const media = practitioner.avatar != null && typeof practitioner.avatar === "object" ? {
+    meta: practitioner.avatar
+  } : void 0;
+  return {
+    id: BigInt(index + 1),
+    externalId: practitioner.id,
+    name: practitioner.name,
+    type: models.OFFERING_RESOURCE_TYPE.PEOPLE,
+    status: models.STATUS.ACTIVE,
+    media,
+    updatedAt: practitioner.updated_at ? new Date(practitioner.updated_at) : void 0,
+    meta: {
+      organisationId: practitioner.organisation_id,
+      siteIds: practitioner.site_ids,
+      appointmentRestrictions: practitioner.appointment_restrictions,
+      tagIds: practitioner.tag_ids,
+      tags: practitioner.tags,
+      zones: practitioner.zones,
+      canOfferTags: practitioner.can_offer_tags,
+      createdAt: practitioner.created_at,
+      updatedAt: practitioner.updated_at
+    }
+  };
+}
+__name(mapTrybePractitionerToOfferingResource, "mapTrybePractitionerToOfferingResource");
 function mapTrybeAppointmentsToSystemResponse(appointments, totalCount, courseLookup) {
   const records = appointments.map((apt, index) => {
     const linkedCourses = courseLookup?.get(apt.id) ?? [];
@@ -1427,6 +3027,14 @@ function mapTrybeCategoriesToSystemResponse(categories, totalCount) {
   };
 }
 __name(mapTrybeCategoriesToSystemResponse, "mapTrybeCategoriesToSystemResponse");
+function mapTrybePractitionersToSystemResponse(practitioners, totalCount) {
+  const records = practitioners.map((practitioner, index) => mapTrybePractitionerToOfferingResource(practitioner, index));
+  return {
+    totalCount,
+    records
+  };
+}
+__name(mapTrybePractitionersToSystemResponse, "mapTrybePractitionersToSystemResponse");
 function mapTrybeOfferingTypeToBookableItemType(offeringType) {
   switch (offeringType) {
     case TRYBE_OFFERING_TYPE_ENUM.APPOINTMENT:
@@ -1528,17 +3136,17 @@ function mapTrybeAppointmentAvailabilityToSystemResponse(slots) {
 __name(mapTrybeAppointmentAvailabilityToSystemResponse, "mapTrybeAppointmentAvailabilityToSystemResponse");
 
 // ../../packages/dvss-integration-trybe/src/capabilities/wellness/wellness-management.service.ts
-function _ts_decorate14(decorators, target, key, desc) {
+function _ts_decorate16(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate14, "_ts_decorate");
-function _ts_metadata11(k, v) {
+__name(_ts_decorate16, "_ts_decorate");
+function _ts_metadata13(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata11, "_ts_metadata");
+__name(_ts_metadata13, "_ts_metadata");
 exports.TrybeWellnessManagement = class _TrybeWellnessManagement {
   static {
     __name(this, "TrybeWellnessManagement");
@@ -1552,9 +3160,6 @@ exports.TrybeWellnessManagement = class _TrybeWellnessManagement {
     this.trafficGatewayService = trafficGatewayService;
     this.trybeAuthService = trybeAuthService;
   }
-  fetchPractitioners() {
-    throw new Error("Method not implemented.");
-  }
   fetchWellnessAppointmentSession() {
     throw new Error("Method not implemented.");
   }
@@ -1570,6 +3175,265 @@ exports.TrybeWellnessManagement = class _TrybeWellnessManagement {
   confirmWellnessAppointmentSessionOrder() {
     throw new Error("Method not implemented.");
   }
+  async createOrder(request, integration, loggedInUserId) {
+    let orderId;
+    try {
+      const validated = this.trybeAuthService.validateConfig(integration, loggedInUserId);
+      const siteId = validated.config.integrationConfig.siteId;
+      const res = await this.trafficGatewayService.executeIntegrationRequest({
+        apiMethod: HTTP_METHOD.POST,
+        url: "/shop/orders",
+        baseUrl: validated.config.platformConfig.baseUrl,
+        headers: validated.headers,
+        body: {
+          site_id: siteId,
+          status: "new"
+        }
+      }, validated, loggedInUserId);
+      orderId = res.data.id;
+      const items = [];
+      await this.addCustomerToOrder(orderId, request.customerId, integration, loggedInUserId);
+      const order = await this.getOrder(orderId, integration, loggedInUserId);
+      for (const bookableItem of request.bookableItems) {
+        const orderItemResponse = await this.addItemToOrder({
+          orderId,
+          item: {
+            offeringId: bookableItem.externalId,
+            offeringType: bookableItem.type,
+            guestIds: order.guests.map((g) => g.id),
+            practitionerIds: request.offeringResources.map((r) => r.externalId),
+            durationMinutes: request.durationInMinutes,
+            timeIso: request.bookingStartTime.toISOString()
+          }
+        }, integration, loggedInUserId);
+        items.push({
+          externalId: bookableItem.externalId,
+          name: orderItemResponse.name,
+          type: bookableItem.type,
+          totalPrice: (orderItemResponse.netTotal ?? 0) / request.currencyMultiplier
+        });
+      }
+      if (request.customerCreditId) {
+        await this.addCustomerCreditsToOrder(orderId, request.customerCreditId, integration, loggedInUserId);
+      }
+      await this.submitOrder(orderId, integration, loggedInUserId);
+      this.logger.info(loggedInUserId, this.createOrder.name, this.fileName, "Created Trybe order for offering booking", {
+        orderId
+      });
+      return {
+        externalBookingId: orderId,
+        items,
+        meta: {
+          orderReference: order.meta.orderReference
+        }
+      };
+    } catch (err) {
+      this.logger.error(loggedInUserId, this.createOrder.name, this.fileName, "Error creating Trybe order for offering booking", err);
+      if (orderId) {
+        await this.cancelOrder(orderId, integration, loggedInUserId);
+      }
+      throw err;
+    }
+  }
+  async addCustomerToOrder(orderId, customerId, integration, loggedInUserId) {
+    const validated = this.trybeAuthService.validateConfig(integration, loggedInUserId);
+    await this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.POST,
+      url: `/shop/orders/${orderId}/customer`,
+      baseUrl: validated.config.platformConfig.baseUrl,
+      headers: validated.headers,
+      body: {
+        id: customerId,
+        source: "trybe"
+      }
+    }, validated, loggedInUserId);
+  }
+  async getOrder(orderId, integration, loggedInUserId) {
+    const validated = this.trybeAuthService.validateConfig(integration, loggedInUserId);
+    const res = await this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.GET,
+      url: `/shop/orders/${orderId}`,
+      baseUrl: validated.config.platformConfig.baseUrl,
+      headers: validated.headers
+    }, validated, loggedInUserId);
+    return {
+      orderId: res.data.id,
+      guests: res.data.guests.map((g) => ({
+        id: g.id,
+        name: g.name
+      })),
+      meta: {
+        orderReference: res.data.order_ref
+      },
+      items: res.data.booking_items ?? []
+    };
+  }
+  mapOfferingTypeToTrybeApi(type) {
+    switch (type) {
+      case BOOKABLE_ITEM_TYPE_ENUM.APPOINTMENT:
+        return TRYBE_OFFERING_TYPE_API.APPOINTMENT;
+      case BOOKABLE_ITEM_TYPE_ENUM.SESSION:
+        return TRYBE_OFFERING_TYPE_API.SESSION;
+      case BOOKABLE_ITEM_TYPE_ENUM.COURSE:
+        return TRYBE_OFFERING_TYPE_API.COURSE;
+      default:
+        throw new Error(`Unsupported offering type: ${type}`);
+    }
+  }
+  async addItemToOrder(request, integration, loggedInUserId) {
+    const validated = this.trybeAuthService.validateConfig(integration, loggedInUserId);
+    const { orderId, item } = request;
+    const offeringType = this.mapOfferingTypeToTrybeApi(item.offeringType);
+    let body;
+    if (offeringType === TRYBE_OFFERING_TYPE_API.APPOINTMENT) {
+      if (item.durationMinutes == null || !item.timeIso) {
+        throw new Error("durationMinutes and timeIso required for appointment");
+      }
+      body = {
+        offering_type: offeringType,
+        offering_id: item.offeringId,
+        guest_ids: item.guestIds,
+        item_configuration: {
+          duration: item.durationMinutes,
+          skip_availability_checks: false,
+          time: item.timeIso
+        },
+        skip_availability_checks: false
+      };
+    } else if (offeringType === TRYBE_OFFERING_TYPE_API.SESSION) {
+      if (!item.sessionId) {
+        throw new Error("sessionId required for session");
+      }
+      body = {
+        offering_type: offeringType,
+        offering_id: item.offeringId,
+        guest_ids: item.guestIds,
+        item_configuration: {
+          session_id: item.sessionId,
+          skip_availability_checks: false
+        },
+        skip_availability_checks: false
+      };
+    } else {
+      body = {
+        offering_type: offeringType,
+        offering_id: item.offeringId,
+        guest_ids: item.guestIds
+      };
+    }
+    const res = await this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.POST,
+      url: `/shop/orders/${orderId}/items`,
+      baseUrl: validated.config.platformConfig.baseUrl,
+      headers: validated.headers,
+      body
+    }, validated, loggedInUserId);
+    const d = res.data;
+    return {
+      name: d.booking_summary?.offering?.name ?? d.type_name ?? void 0,
+      netTotal: d.net_total
+    };
+  }
+  async addCustomerCreditsToOrder(orderId, customerCreditId, integration, loggedInUserId) {
+    const validated = this.trybeAuthService.validateConfig(integration, loggedInUserId);
+    await this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.POST,
+      url: `/shop/orders/${orderId}/customer-credits`,
+      baseUrl: validated.config.platformConfig.baseUrl,
+      headers: validated.headers,
+      body: {
+        id: customerCreditId
+      }
+    }, validated, loggedInUserId);
+  }
+  async submitOrder(orderId, integration, loggedInUserId) {
+    const validated = this.trybeAuthService.validateConfig(integration, loggedInUserId);
+    await this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.POST,
+      url: `/shop/orders/${orderId}/submit`,
+      baseUrl: validated.config.platformConfig.baseUrl,
+      headers: validated.headers
+    }, validated, loggedInUserId);
+  }
+  async cancelOrder(orderId, integration, loggedInUserId) {
+    const validated = this.trybeAuthService.validateConfig(integration, loggedInUserId);
+    await this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.POST,
+      url: `/shop/orders/${orderId}/cancel`,
+      baseUrl: validated.config.platformConfig.baseUrl,
+      headers: validated.headers
+    }, validated, loggedInUserId);
+  }
+  async updateOrder(request, integration, loggedInUserId) {
+    const order = await this.getOrder(request.orderId, integration, loggedInUserId);
+    const itemId = order.items[0]?.id;
+    if (!itemId) {
+      throw new Error("Item not found in order");
+    }
+    const updateResponse = await this.updateOrderItem(request.orderId, itemId, request, integration, loggedInUserId);
+    return {
+      success: Boolean(updateResponse.data.id),
+      data: updateResponse.data
+    };
+  }
+  async updateOrderItem(orderId, itemId, request, integration, loggedInUserId) {
+    const validated = this.trybeAuthService.validateConfig(integration, loggedInUserId);
+    const offeringType = this.mapOfferingTypeToTrybeApi(request.item.type);
+    let body;
+    if (offeringType === TRYBE_OFFERING_TYPE_API.APPOINTMENT) {
+      if (request.bookingStartTimeLabel == null || request.durationInMinutes == null || request.bookingStartDateLabel == null) {
+        throw new Error("durationInMinutes, bookingStartDateLabel and bookingStartTimeLabel required for appointment");
+      }
+      const timeIso = dvssBackendModuleUtility.convertDateOnlyToTimestamp(request.timezone, request.bookingStartDateLabel, request.bookingStartTimeLabel).toISOString();
+      body = {
+        offering_id: request.item.externalId,
+        item_configuration: {
+          time: timeIso,
+          duration: request.durationInMinutes,
+          skip_availability_checks: false
+        },
+        skip_availability_checks: false
+      };
+    } else if (offeringType === TRYBE_OFFERING_TYPE_API.SESSION) {
+      if (!request.sessionId) {
+        throw new Error("sessionId required for session");
+      }
+      body = {
+        item_configuration: {
+          session_id: request.sessionId,
+          skip_availability_checks: false
+        }
+      };
+    } else {
+      throw new Error("Course is not updatable");
+    }
+    const res = await this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.PUT,
+      url: `/shop/orders/${orderId}/items/${itemId}`,
+      baseUrl: validated.config.platformConfig.baseUrl,
+      headers: validated.headers,
+      body
+    }, validated, loggedInUserId);
+    return res;
+  }
+  async addPaymentToOrder(request, integration, loggedInUserId) {
+    const validated = this.trybeAuthService.validateConfig(integration, loggedInUserId);
+    await this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.POST,
+      url: `/shop/orders/${request.orderId}/payments`,
+      baseUrl: validated.config.platformConfig.baseUrl,
+      headers: validated.headers,
+      body: {
+        amount: request.amount,
+        processor: "manual",
+        status: "paid",
+        processor_data: {
+          notes: "",
+          payment_type_id: request.paymentTypeId
+        }
+      }
+    }, validated, loggedInUserId);
+  }
   async fetchAppointments(request, integration, loggedInUserId) {
     this.logger.info(loggedInUserId, this.fetchAppointments.name, this.fileName, `${_TrybeWellnessManagement.name} -> ${this.fetchAppointments.name} Called`, {
       request
@@ -1666,6 +3530,27 @@ exports.TrybeWellnessManagement = class _TrybeWellnessManagement {
     }, validatedIntegration, loggedInUserId));
     return mapTrybeCoursesToSystemResponse(records, firstPageResponse.meta.total);
   }
+  async fetchPractitioners(request, integration, loggedInUserId) {
+    this.logger.info(loggedInUserId, this.fetchPractitioners.name, this.fileName, `${_TrybeWellnessManagement.name} -> ${this.fetchPractitioners.name} Called`, {
+      request
+    });
+    const validatedIntegration = this.trybeAuthService.validateConfig(integration, loggedInUserId);
+    const siteId = validatedIntegration.config.integrationConfig.siteId;
+    const apiUrl = `/shop/practitioners/?site_id=${siteId}`;
+    const firstPageResponse = await this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.GET,
+      url: apiUrl,
+      baseUrl: validatedIntegration.config.platformConfig.baseUrl,
+      headers: validatedIntegration.headers
+    }, validatedIntegration, loggedInUserId);
+    const records = await fetchAllPages(firstPageResponse, request.shouldFetchAllPractitioners, (page) => this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.GET,
+      url: `${apiUrl}&page=${page}`,
+      baseUrl: validatedIntegration.config.platformConfig.baseUrl,
+      headers: validatedIntegration.headers
+    }, validatedIntegration, loggedInUserId));
+    return mapTrybePractitionersToSystemResponse(records, firstPageResponse.meta.total);
+  }
   async fetchCategories(request, integration, loggedInUserId) {
     this.logger.info(loggedInUserId, this.fetchCategories.name, this.fileName, `${_TrybeWellnessManagement.name} -> ${this.fetchCategories.name} Called`, {
       request
@@ -1755,30 +3640,120 @@ exports.TrybeWellnessManagement = class _TrybeWellnessManagement {
     return mapTrybeAppointmentAvailabilityToSystemResponse(response.data);
   }
 };
-exports.TrybeWellnessManagement = _ts_decorate14([
+exports.TrybeWellnessManagement = _ts_decorate16([
   common.Injectable(),
-  _ts_metadata11("design:type", Function),
-  _ts_metadata11("design:paramtypes", [
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof dvssBackendModuleUtility.LoggerService === "undefined" ? Object : dvssBackendModuleUtility.LoggerService,
     typeof exports.TrafficGatewayService === "undefined" ? Object : exports.TrafficGatewayService,
     typeof exports.TrybeAuthService === "undefined" ? Object : exports.TrybeAuthService
   ])
 ], exports.TrybeWellnessManagement);
 
+// ../../packages/dvss-integration-trybe/src/capabilities/integration-configuration/integration-configuration.mapper.ts
+function mapTrybeSiteResponseToSystem(response) {
+  return {
+    customPaymentTypes: response.data?.custom_payment_types?.map((paymentType) => ({
+      id: paymentType.id,
+      name: paymentType.name,
+      kind: paymentType.kind
+    }))
+  };
+}
+__name(mapTrybeSiteResponseToSystem, "mapTrybeSiteResponseToSystem");
+
+// ../../packages/dvss-integration-trybe/src/capabilities/integration-configuration/integration-configuration.service.ts
+function _ts_decorate17(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate17, "_ts_decorate");
+function _ts_metadata14(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata14, "_ts_metadata");
+exports.TrybeIntegrationConfigurationService = class TrybeIntegrationConfigurationService extends BaseIntegrationConfiguration {
+  static {
+    __name(this, "TrybeIntegrationConfigurationService");
+  }
+  trybeAuthService;
+  trafficGatewayService;
+  constructor(integrationConfigurationDao, commonValidationDatabaseService, trybeAuthService, trafficGatewayService) {
+    super(integrationConfigurationDao, commonValidationDatabaseService), this.trybeAuthService = trybeAuthService, this.trafficGatewayService = trafficGatewayService;
+  }
+  /**
+  * Add capability integration: validate Trybe config, then configuredFor (offering), then delegate to base.
+  */
+  async addCapabilityIntegration(input, context) {
+    this.trybeAuthService.validateConfig({
+      config: input.config
+    }, context.loggedInUserId);
+    if (input.configuredFor != null) {
+      await this.validateCapabilityIntegrationConfiguredForInput(input.configuredFor, input.projectId);
+    }
+    return super.addCapabilityIntegration(input, context);
+  }
+  /**
+  * Update capability integration: delegate to base.
+  */
+  async updateCapabilityIntegration(id, updateData, context) {
+    return super.updateCapabilityIntegration(id, updateData, context);
+  }
+  /**
+  * Validates configuredFor (offering exists and belongs to project). Same as project-ms validateCapabilityIntegrationConfiguredForInput.
+  */
+  async validateCapabilityIntegrationConfiguredForInput(configuredFor, projectId) {
+    if (configuredFor.configuredForType !== models.CONFIGURED_FOR_TYPE_ENUM.OFFERING) {
+      throw new Error(`configuredForType not supported: ${configuredFor.configuredForType}`);
+    }
+    await this.commonValidationDatabaseService.getOffering({
+      offeringId: configuredFor.configuredForId,
+      projectId
+    });
+  }
+  /**
+  * Trybe 3rd party: GET /shop/sites/{siteId} via executeIntegrationRequest.
+  */
+  async getSiteDetailedInformation(integration, loggedInUserId) {
+    const validatedIntegration = this.trybeAuthService.validateConfig(integration, loggedInUserId);
+    const siteId = validatedIntegration.config.integrationConfig.siteId;
+    const url = `/shop/sites/${siteId}`;
+    const response = await this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.GET,
+      url,
+      baseUrl: validatedIntegration.config.platformConfig.baseUrl,
+      headers: validatedIntegration.headers
+    }, validatedIntegration, loggedInUserId);
+    return mapTrybeSiteResponseToSystem(response);
+  }
+};
+exports.TrybeIntegrationConfigurationService = _ts_decorate17([
+  common.Injectable(),
+  _ts_metadata14("design:type", Function),
+  _ts_metadata14("design:paramtypes", [
+    typeof exports.IntegrationConfigurationDao === "undefined" ? Object : exports.IntegrationConfigurationDao,
+    typeof dvssBackendModuleDatastore.CommonValidationDatabaseService === "undefined" ? Object : dvssBackendModuleDatastore.CommonValidationDatabaseService,
+    typeof exports.TrybeAuthService === "undefined" ? Object : exports.TrybeAuthService,
+    typeof exports.TrafficGatewayService === "undefined" ? Object : exports.TrafficGatewayService
+  ])
+], exports.TrybeIntegrationConfigurationService);
+
 // ../../packages/dvss-integration-trybe/src/app.module.ts
-function _ts_decorate15(decorators, target, key, desc) {
+function _ts_decorate18(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate15, "_ts_decorate");
+__name(_ts_decorate18, "_ts_decorate");
 exports.IntegrationTrybeModule = class AppModule2 {
   static {
     __name(this, "AppModule");
   }
 };
-exports.IntegrationTrybeModule = _ts_decorate15([
+exports.IntegrationTrybeModule = _ts_decorate18([
   common.Module({
     imports: [
       // Load environment variables from root .env file
@@ -1788,7 +3763,8 @@ exports.IntegrationTrybeModule = _ts_decorate15([
       }),
       exports.IntegrationLibsModule,
       axios.HttpModule,
-      dvssBackendModuleUtility.LoggerModule
+      dvssBackendModuleUtility.LoggerModule,
+      dvssBackendModuleDatastore.DatastoreModule
     ],
     controllers: [
       AppController2
@@ -1798,31 +3774,40 @@ exports.IntegrationTrybeModule = _ts_decorate15([
       exports.TrybeAuthService,
       exports.TrybeCustomerManagement,
       exports.TrybeCreditBooking,
-      exports.TrybeWellnessManagement
+      exports.TrybeWellnessManagement,
+      exports.IntegrationConfigurationDao,
+      exports.IntegrationRequestLoggerService,
+      exports.RateLimiterService,
+      exports.TrafficGatewayService,
+      exports.TrybeCustomerManagement,
+      exports.TrybeAuthService,
+      exports.TrybeIntegrationConfigurationService,
+      dvssBackendModuleDatastore.CommonValidationDatabaseService
     ],
     exports: [
       exports.TrybeAuthService,
       exports.TrybeCustomerManagement,
       exports.TrybeCreditBooking,
-      exports.TrybeWellnessManagement
+      exports.TrybeWellnessManagement,
+      exports.TrybeIntegrationConfigurationService
     ]
   })
 ], exports.IntegrationTrybeModule);
 
 // src/app.module.ts
-function _ts_decorate16(decorators, target, key, desc) {
+function _ts_decorate19(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate16, "_ts_decorate");
+__name(_ts_decorate19, "_ts_decorate");
 exports.OfferingIntegrationManager = class AppModule3 {
   static {
     __name(this, "AppModule");
   }
 };
-exports.OfferingIntegrationManager = _ts_decorate16([
+exports.OfferingIntegrationManager = _ts_decorate19([
   common.Module({
     imports: [
       exports.IntegrationTrybeModule,
@@ -1855,6 +3840,7 @@ exports.BaseAccountingTaxManagement = BaseAccountingTaxManagement;
 exports.BaseAuth = BaseAuth;
 exports.BaseCreditBooking = BaseCreditBooking;
 exports.BaseCustomerManagement = BaseCustomerManagement;
+exports.BaseIntegrationConfiguration = BaseIntegrationConfiguration;
 exports.BaseMembershipCustomerManagement = BaseMembershipCustomerManagement;
 exports.BaseMembershipManagement = BaseMembershipManagement;
 exports.BasePackageManagement = BasePackageManagement;
@@ -1865,10 +3851,10 @@ exports.BaseWellnessManagement = BaseWellnessManagement;
 exports.CREDIT_FILTER_BY_ENUM = CREDIT_FILTER_BY_ENUM;
 exports.CREDIT_STATUS_ENUM = CREDIT_STATUS_ENUM;
 exports.CREDIT_TYPE_ENUM = CREDIT_TYPE_ENUM;
-exports.DAY_OF_WEEK = DAY_OF_WEEK;
 exports.HTTP_METHOD = HTTP_METHOD;
 exports.INTEGRATION_PROVIDER_ENUM = INTEGRATION_PROVIDER_ENUM;
 exports.TRAFFIC_ROUTER_CONFIGURATION_STORE_KEY = TRAFFIC_ROUTER_CONFIGURATION_STORE_KEY;
+exports.TRYBE_OFFERING_TYPE_API = TRYBE_OFFERING_TYPE_API;
 exports.TRYBE_OFFERING_TYPE_ENUM = TRYBE_OFFERING_TYPE_ENUM;
 exports.convertKeysToCamelCase = convertKeysToCamelCase;
 exports.extractTimeFromIsoString = extractTimeFromIsoString;