@flusys/nestjs-form-builder 7.1.0 → 8.0.0

package/fesm/262.js

@@ -0,0 +1,1841 @@
+import { Identity, getJsonColumnType } from "@flusys/nestjs-shared";
+import { Identity as entities_Identity } from "@flusys/nestjs-shared/entities";
+import * as __rspack_external__flusys_nestjs_shared_classes_6076a329 from "@flusys/nestjs-shared/classes";
+import * as __rspack_external__flusys_nestjs_shared_decorators_c129b601 from "@flusys/nestjs-shared/decorators";
+import * as __rspack_external__flusys_nestjs_shared_dtos_c4585026 from "@flusys/nestjs-shared/dtos";
+import * as __rspack_external__flusys_nestjs_shared_modules_24702bee from "@flusys/nestjs-shared/modules";
+import * as __rspack_external__nestjs_common_a04939da from "@nestjs/common";
+import * as __rspack_external__nestjs_swagger_7cd450b5 from "@nestjs/swagger";
+import * as __rspack_external_class_transformer_c5a479fb from "class-transformer";
+import * as __rspack_external_class_validator_7b99ef4d from "class-validator";
+import * as __rspack_external_typeorm from "typeorm";
+import * as __rspack_external__flusys_nestjs_core_ff4ca4e2 from "@flusys/nestjs-core";
+import * as __rspack_external__flusys_nestjs_shared_utils_9125c1f1 from "@flusys/nestjs-shared/utils";
+import * as __rspack_external__nestjs_core_d7b00a1a from "@nestjs/core";
+export const __rspack_esm_id = 262;
+export const __rspack_esm_ids = [262];
+export const __webpack_modules__ = {
+769(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/**
+ * Domain event actions published by the form builder module, alongside the
+ * CRUD lifecycle actions every ApiService emits.
+ */ const FORM_BUILDER_EVENT_ACTIONS = {
+    SUBMITTED: 'submitted',
+    DRAFT_SAVED: 'draft-saved'
+};
+/** Every entity the form builder module publishes under */ const FORM_BUILDER_EVENT_ENTITIES = {
+    FORM: 'form',
+    FORM_RESULT: 'form_result'
+};
+const FORM_BUILDER_EVENT_MODULE = 'form-builder';
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  T$: FORM_BUILDER_EVENT_MODULE,
+  eF: FORM_BUILDER_EVENT_ENTITIES,
+  ov: FORM_BUILDER_EVENT_ACTIONS
+});
+
+
+},
+512(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+const FORM_BUILDER_MODULE_OPTIONS = 'FORM_BUILDER_MODULE_OPTIONS';
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  v: FORM_BUILDER_MODULE_OPTIONS
+});
+
+
+},
+137(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+// ==================== FORM BUILDER MODULE MESSAGE KEYS ====================
+const FORM_MESSAGES = {
+    NOT_FOUND: 'form.not.found',
+    NOT_PUBLIC: 'form.not.public',
+    AUTH_REQUIRED: 'form.auth.required',
+    ACCESS_DENIED: 'form.access.denied',
+    INVALID_ACCESS_TYPE: 'form.invalid.access.type',
+    PERMISSION_CHECK_FAILED: 'form.permission.check.failed',
+    GET_SUCCESS: 'form.get.success',
+    GET_ACCESS_INFO_SUCCESS: 'form.get.access.info.success'
+};
+const FORM_RESULT_MESSAGES = {
+    GET_ALL_SUCCESS: 'form.result.get.all.success',
+    NOT_FOUND: 'form.result.not.found',
+    HAS_SUBMITTED_SUCCESS: 'form.result.has.submitted.success',
+    HAS_NOT_SUBMITTED_SUCCESS: 'form.result.has.not.submitted.success',
+    SUBMIT_SUCCESS: 'form.result.submit.success',
+    DRAFT_GET_SUCCESS: 'form.result.draft.get.success',
+    DRAFT_UPDATE_SUCCESS: 'form.result.draft.update.success'
+};
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  Q: FORM_MESSAGES,
+  y: FORM_RESULT_MESSAGES
+});
+
+
+},
+788(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _flusys_nestjs_shared_dtos__rspack_import_0 = __webpack_require__(873);
+/* import */ var _nestjs_swagger__rspack_import_1 = __webpack_require__(176);
+/* import */ var class_transformer__rspack_import_2 = __webpack_require__(812);
+/* import */ var class_validator__rspack_import_3 = __webpack_require__(421);
+function _ts_decorate(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;
+}
+function _ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+
+
+class SubmitFormDto {
+    formId;
+    data;
+    isDraft;
+}
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_1.ApiProperty)({
+        description: 'Form ID to submit',
+        example: '123e4567-e89b-12d3-a456-426614174000'
+    }),
+    (0,class_validator__rspack_import_3.IsUUID)(),
+    (0,class_validator__rspack_import_3.IsNotEmpty)(),
+    _ts_metadata("design:type", String)
+], SubmitFormDto.prototype, "formId", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_1.ApiProperty)({
+        description: 'Submitted form data (field values)',
+        example: {
+            field1: 'value1',
+            field2: 123
+        }
+    }),
+    (0,class_validator__rspack_import_3.IsObject)(),
+    (0,class_validator__rspack_import_3.IsNotEmpty)(),
+    _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], SubmitFormDto.prototype, "data", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_1.ApiProperty)({
+        description: 'Save as draft instead of final submission',
+        default: false,
+        required: false
+    }),
+    (0,class_validator__rspack_import_3.IsBoolean)(),
+    (0,class_validator__rspack_import_3.IsOptional)(),
+    _ts_metadata("design:type", Boolean)
+], SubmitFormDto.prototype, "isDraft", void 0);
+class CreateFormResultDto extends SubmitFormDto {
+    schemaVersionSnapshot;
+    schemaVersion;
+    submittedById;
+}
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_1.ApiProperty)({
+        description: 'Schema snapshot at submission time',
+        required: false
+    }),
+    (0,class_validator__rspack_import_3.IsObject)(),
+    (0,class_validator__rspack_import_3.IsOptional)(),
+    _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], CreateFormResultDto.prototype, "schemaVersionSnapshot", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_1.ApiProperty)({
+        description: 'Schema version at submission time',
+        required: false
+    }),
+    (0,class_validator__rspack_import_3.IsOptional)(),
+    _ts_metadata("design:type", Number)
+], CreateFormResultDto.prototype, "schemaVersion", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_1.ApiProperty)({
+        description: 'User who submitted (null for public)',
+        required: false
+    }),
+    (0,class_validator__rspack_import_3.IsUUID)(),
+    (0,class_validator__rspack_import_3.IsOptional)(),
+    _ts_metadata("design:type", Object)
+], CreateFormResultDto.prototype, "submittedById", void 0);
+class UpdateFormResultDto extends (0,_nestjs_swagger__rspack_import_1.PartialType)(CreateFormResultDto) {
+    id;
+}
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_1.ApiProperty)({
+        description: 'Form Result ID',
+        example: '123e4567-e89b-12d3-a456-426614174000'
+    }),
+    (0,class_validator__rspack_import_3.IsUUID)(),
+    (0,class_validator__rspack_import_3.IsNotEmpty)(),
+    _ts_metadata("design:type", String)
+], UpdateFormResultDto.prototype, "id", void 0);
+class GetMyDraftDto {
+    formId;
+}
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_1.ApiProperty)({
+        description: 'Form ID to get draft for',
+        example: '123e4567-e89b-12d3-a456-426614174000'
+    }),
+    (0,class_validator__rspack_import_3.IsUUID)(),
+    (0,class_validator__rspack_import_3.IsNotEmpty)(),
+    _ts_metadata("design:type", String)
+], GetMyDraftDto.prototype, "formId", void 0);
+class UpdateDraftDto extends SubmitFormDto {
+    draftId;
+}
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_1.ApiProperty)({
+        description: 'Draft ID to update',
+        example: '123e4567-e89b-12d3-a456-426614174000'
+    }),
+    (0,class_validator__rspack_import_3.IsUUID)(),
+    (0,class_validator__rspack_import_3.IsNotEmpty)(),
+    _ts_metadata("design:type", String)
+], UpdateDraftDto.prototype, "draftId", void 0);
+class GetResultsByFormDto {
+    formId;
+    page;
+    pageSize;
+}
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_1.ApiProperty)({
+        description: 'Form ID to filter results',
+        example: '123e4567-e89b-12d3-a456-426614174000'
+    }),
+    (0,class_validator__rspack_import_3.IsUUID)(),
+    (0,class_validator__rspack_import_3.IsNotEmpty)(),
+    _ts_metadata("design:type", String)
+], GetResultsByFormDto.prototype, "formId", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_1.ApiProperty)({
+        description: 'Page number (0-based)',
+        default: 0,
+        required: false
+    }),
+    (0,class_validator__rspack_import_3.IsInt)(),
+    (0,class_validator__rspack_import_3.Min)(0),
+    (0,class_validator__rspack_import_3.IsOptional)(),
+    _ts_metadata("design:type", Number)
+], GetResultsByFormDto.prototype, "page", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_1.ApiProperty)({
+        description: 'Page size',
+        default: 10,
+        required: false
+    }),
+    (0,class_validator__rspack_import_3.IsInt)(),
+    (0,class_validator__rspack_import_3.Min)(1),
+    (0,class_validator__rspack_import_3.IsOptional)(),
+    _ts_metadata("design:type", Number)
+], GetResultsByFormDto.prototype, "pageSize", void 0);
+class FormResultResponseDto extends _flusys_nestjs_shared_dtos__rspack_import_0.IdentityResponseDto {
+    formId;
+    schemaVersionSnapshot;
+    schemaVersion;
+    data;
+    submittedById;
+    submittedAt;
+    isDraft;
+}
+_ts_decorate([
+    (0,class_transformer__rspack_import_2.Expose)(),
+    (0,_nestjs_swagger__rspack_import_1.ApiProperty)(),
+    _ts_metadata("design:type", String)
+], FormResultResponseDto.prototype, "formId", void 0);
+_ts_decorate([
+    (0,class_transformer__rspack_import_2.Expose)(),
+    (0,_nestjs_swagger__rspack_import_1.ApiProperty)(),
+    _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], FormResultResponseDto.prototype, "schemaVersionSnapshot", void 0);
+_ts_decorate([
+    (0,class_transformer__rspack_import_2.Expose)(),
+    (0,_nestjs_swagger__rspack_import_1.ApiProperty)(),
+    _ts_metadata("design:type", Number)
+], FormResultResponseDto.prototype, "schemaVersion", void 0);
+_ts_decorate([
+    (0,class_transformer__rspack_import_2.Expose)(),
+    (0,_nestjs_swagger__rspack_import_1.ApiProperty)(),
+    _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], FormResultResponseDto.prototype, "data", void 0);
+_ts_decorate([
+    (0,class_transformer__rspack_import_2.Expose)(),
+    (0,_nestjs_swagger__rspack_import_1.ApiProperty)(),
+    _ts_metadata("design:type", Object)
+], FormResultResponseDto.prototype, "submittedById", void 0);
+_ts_decorate([
+    (0,class_transformer__rspack_import_2.Expose)(),
+    (0,_nestjs_swagger__rspack_import_1.ApiProperty)(),
+    _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], FormResultResponseDto.prototype, "submittedAt", void 0);
+_ts_decorate([
+    (0,class_transformer__rspack_import_2.Expose)(),
+    (0,_nestjs_swagger__rspack_import_1.ApiProperty)(),
+    _ts_metadata("design:type", Boolean)
+], FormResultResponseDto.prototype, "isDraft", void 0);
+
+__webpack_require__.d(__webpack_exports__, {
+  CQ: () => (UpdateDraftDto),
+  D5: () => (GetMyDraftDto),
+  Uj: () => (UpdateFormResultDto),
+  _$: () => (FormResultResponseDto),
+  pZ: () => (CreateFormResultDto),
+  rp: () => (GetResultsByFormDto),
+  sH: () => (SubmitFormDto)
+});
+
+
+},
+532(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  lV: () => (/* reexport */ Form),
+  C7: () => (/* reexport */ Form),
+  Xl: () => (/* binding */ FormCompanyEntities),
+  t$: () => (/* binding */ FormCoreEntities),
+  ez: () => (/* reexport */ FormResult),
+  Wl: () => (/* reexport */ FormWithCompany),
+  getFormBuilderEntitiesByConfig: () => (/* binding */ getFormBuilderEntitiesByConfig)
+});
+
+;// CONCATENATED MODULE: external "@flusys/nestjs-shared"
+
+;// CONCATENATED MODULE: external "@flusys/nestjs-shared/entities"
+
+// EXTERNAL MODULE: external "typeorm"
+var external_typeorm_ = __webpack_require__(158);
+// EXTERNAL MODULE: ./projects/nestjs-form-builder/src/enums/form-access-type.enum.ts
+var form_access_type_enum = __webpack_require__(376);
+;// CONCATENATED MODULE: ./projects/nestjs-form-builder/src/entities/form.entity.ts
+function _ts_decorate(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;
+}
+function _ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+
+
+class Form extends entities_Identity {
+    name;
+    description;
+    slug;
+    schema;
+    schemaVersion;
+    accessType;
+    actionGroups;
+    tags;
+    isActive;
+}
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 255,
+        nullable: false
+    }),
+    _ts_metadata("design:type", String)
+], Form.prototype, "name", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 500,
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], Form.prototype, "description", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 255,
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], Form.prototype, "slug", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: getJsonColumnType(),
+        nullable: false
+    }),
+    _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], Form.prototype, "schema", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'int',
+        nullable: false,
+        default: 1,
+        name: 'schema_version'
+    }),
+    _ts_metadata("design:type", Number)
+], Form.prototype, "schemaVersion", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 50,
+        default: 'AUTHENTICATED',
+        name: 'access_type'
+    }),
+    _ts_metadata("design:type", typeof form_access_type_enum/* .FormAccessType */.h === "undefined" ? Object : form_access_type_enum/* .FormAccessType */.h)
+], Form.prototype, "accessType", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: getJsonColumnType(),
+        nullable: true,
+        name: 'action_groups'
+    }),
+    _ts_metadata("design:type", Object)
+], Form.prototype, "actionGroups", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: getJsonColumnType(),
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], Form.prototype, "tags", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'boolean',
+        nullable: false,
+        default: true,
+        name: 'is_active'
+    }),
+    _ts_metadata("design:type", Boolean)
+], Form.prototype, "isActive", void 0);
+Form = _ts_decorate([
+    (0,external_typeorm_.Entity)({
+        name: 'form'
+    }),
+    (0,external_typeorm_.Index)([
+        'slug'
+    ], {
+        unique: true
+    }),
+    (0,external_typeorm_.Index)([
+        'isActive'
+    ])
+], Form);
+
+;// CONCATENATED MODULE: ./projects/nestjs-form-builder/src/entities/form-result.entity.ts
+function form_result_entity_ts_decorate(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;
+}
+function form_result_entity_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+class FormResult extends Identity {
+    formId;
+    schemaVersionSnapshot;
+    schemaVersion;
+    data;
+    submittedById;
+    submittedAt;
+    isDraft;
+}
+form_result_entity_ts_decorate([
+    (0,external_typeorm_.Index)(),
+    (0,external_typeorm_.Column)({
+        type: 'uuid',
+        nullable: false,
+        name: 'form_id'
+    }),
+    form_result_entity_ts_metadata("design:type", String)
+], FormResult.prototype, "formId", void 0);
+form_result_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: getJsonColumnType(),
+        nullable: false,
+        name: 'schema_version_snapshot'
+    }),
+    form_result_entity_ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], FormResult.prototype, "schemaVersionSnapshot", void 0);
+form_result_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'int',
+        nullable: false,
+        name: 'schema_version'
+    }),
+    form_result_entity_ts_metadata("design:type", Number)
+], FormResult.prototype, "schemaVersion", void 0);
+form_result_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: getJsonColumnType(),
+        nullable: false
+    }),
+    form_result_entity_ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], FormResult.prototype, "data", void 0);
+form_result_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'uuid',
+        nullable: true,
+        name: 'submitted_by_id'
+    }),
+    form_result_entity_ts_metadata("design:type", Object)
+], FormResult.prototype, "submittedById", void 0);
+form_result_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'timestamp',
+        nullable: false,
+        name: 'submitted_at'
+    }),
+    form_result_entity_ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], FormResult.prototype, "submittedAt", void 0);
+form_result_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'boolean',
+        default: false,
+        name: 'is_draft'
+    }),
+    form_result_entity_ts_metadata("design:type", Boolean)
+], FormResult.prototype, "isDraft", void 0);
+FormResult = form_result_entity_ts_decorate([
+    (0,external_typeorm_.Entity)({
+        name: 'form_result'
+    })
+], FormResult);
+
+;// CONCATENATED MODULE: ./projects/nestjs-form-builder/src/entities/form-with-company.entity.ts
+function form_with_company_entity_ts_decorate(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;
+}
+function form_with_company_entity_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+class FormWithCompany extends Form {
+    companyId;
+}
+form_with_company_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'uuid',
+        nullable: true,
+        name: 'company_id'
+    }),
+    form_with_company_entity_ts_metadata("design:type", Object)
+], FormWithCompany.prototype, "companyId", void 0);
+FormWithCompany = form_with_company_entity_ts_decorate([
+    (0,external_typeorm_.Entity)({
+        name: 'form'
+    }),
+    (0,external_typeorm_.Index)([
+        'companyId'
+    ]),
+    (0,external_typeorm_.Index)([
+        'companyId',
+        'slug'
+    ], {
+        unique: true
+    }),
+    (0,external_typeorm_.Index)([
+        'companyId',
+        'isActive'
+    ])
+], FormWithCompany);
+
+;// CONCATENATED MODULE: ./projects/nestjs-form-builder/src/entities/index.ts
+// Entities without company feature
+
+
+// Entities with company feature
+
+
+
+
+// Core entities (no company feature)
+const FormCoreEntities = [
+    Form,
+    FormResult
+];
+// Company-specific entities
+const FormCompanyEntities = [
+    FormWithCompany,
+    FormResult
+];
+function getFormBuilderEntitiesByConfig(enableCompanyFeature) {
+    return enableCompanyFeature ? FormCompanyEntities : FormCoreEntities;
+}
+// Base type aliases for backwards compatibility with services
+
+
+
+},
+376(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/**
+ * Form Access Type Enum
+ * Defines who can submit the form
+ */ var FormAccessType = /*#__PURE__*/ function(FormAccessType) {
+    /** No authentication required - anyone can submit */ FormAccessType["PUBLIC"] = "public";
+    /** Any authenticated user can submit */ FormAccessType["AUTHENTICATED"] = "authenticated";
+    /** Only users with specific action permissions can submit */ FormAccessType["ACTION_GROUP"] = "action_group";
+    return FormAccessType;
+}({});
+
+__webpack_require__.d(__webpack_exports__, {
+  h: () => (FormAccessType)
+});
+
+
+},
+781(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _nestjs_common__rspack_import_0 = __webpack_require__(157);
+/* import */ var _config_form_builder_constants_js__rspack_import_1 = __webpack_require__(512);
+function _ts_decorate(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;
+}
+function _ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+class FormBuilderConfigService {
+    options;
+    constructor(options){
+        this.options = options;
+    }
+    isCompanyFeatureEnabled(tenant) {
+        return tenant?.enableCompanyFeature ?? this.options.bootstrapAppConfig?.enableCompanyFeature ?? false;
+    }
+    getDatabaseMode() {
+        return this.options.bootstrapAppConfig?.databaseMode ?? 'single';
+    }
+    isMultiTenant() {
+        return this.getDatabaseMode() === 'multi-tenant';
+    }
+    getOptions() {
+        return this.options;
+    }
+    getConfig() {
+        return this.options.config;
+    }
+}
+FormBuilderConfigService = _ts_decorate([
+    (0,_nestjs_common__rspack_import_0.Injectable)(),
+    _ts_param(0, (0,_nestjs_common__rspack_import_0.Inject)(_config_form_builder_constants_js__rspack_import_1/* .FORM_BUILDER_MODULE_OPTIONS */.v)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof FormBuilderModuleOptions === "undefined" ? Object : FormBuilderModuleOptions
+    ])
+], FormBuilderConfigService);
+
+__webpack_require__.d(__webpack_exports__, {
+  j: () => (FormBuilderConfigService)
+});
+
+
+},
+593(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  _: () => (/* binding */ FormBuilderDataSourceProvider)
+});
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/modules"
+var modules_ = __webpack_require__(236);
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(157);
+;// CONCATENATED MODULE: external "@nestjs/core"
+
+// EXTERNAL MODULE: ./projects/nestjs-form-builder/src/services/form-builder-config.service.ts
+var form_builder_config_service = __webpack_require__(781);
+;// CONCATENATED MODULE: ./projects/nestjs-form-builder/src/services/form-builder-datasource.provider.ts
+function _ts_decorate(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;
+}
+function _ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+class FormBuilderDataSourceProvider extends modules_.MultiTenantDataSourceService {
+    configService;
+    static tenantConnections = new Map();
+    static singleDataSource = null;
+    static tenantsRegistry = new Map();
+    static initialized = false;
+    static connectionLocks = new Map();
+    static singleConnectionLock = null;
+    constructor(configService, request){
+        super(FormBuilderDataSourceProvider.buildParentOptions(configService.getOptions()), request), this.configService = configService;
+    }
+    static buildParentOptions(options) {
+        return {
+            bootstrapAppConfig: options.bootstrapAppConfig,
+            defaultDatabaseConfig: options.config?.defaultDatabaseConfig,
+            tenantDefaultDatabaseConfig: options.config?.tenantDefaultDatabaseConfig,
+            tenants: options.config?.tenants
+        };
+    }
+    async getFormBuilderEntities(enableCompanyFeature) {
+        const enable = enableCompanyFeature ?? this.configService.isCompanyFeatureEnabled();
+        const { getFormBuilderEntitiesByConfig } = await Promise.resolve(/* import() */).then(__webpack_require__.bind(__webpack_require__, 532));
+        return getFormBuilderEntitiesByConfig(enable);
+    }
+    async createDataSourceFromConfig(config) {
+        const enableCompanyFeature = this.configService.isCompanyFeatureEnabled(this.getCurrentTenant() ?? undefined);
+        const entities = await this.getFormBuilderEntities(enableCompanyFeature);
+        return super.createDataSourceFromConfig(config, entities);
+    }
+}
+FormBuilderDataSourceProvider = _ts_decorate([
+    (0,common_.Injectable)({
+        scope: common_.Scope.REQUEST
+    }),
+    _ts_param(0, (0,common_.Inject)(form_builder_config_service/* .FormBuilderConfigService */.j)),
+    _ts_param(1, (0,common_.Optional)()),
+    _ts_param(1, (0,common_.Inject)(__rspack_external__nestjs_core_d7b00a1a.REQUEST)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof form_builder_config_service/* .FormBuilderConfigService */.j === "undefined" ? Object : form_builder_config_service/* .FormBuilderConfigService */.j,
+        typeof Request === "undefined" ? Object : Request
+    ])
+], FormBuilderDataSourceProvider);
+
+
+},
+160(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _flusys_nestjs_shared_classes__rspack_import_0 = __webpack_require__(937);
+/* import */ var _flusys_nestjs_shared_decorators__rspack_import_1 = __webpack_require__(265);
+/* import */ var _flusys_nestjs_shared_modules__rspack_import_2 = __webpack_require__(236);
+/* import */ var _nestjs_common__rspack_import_3 = __webpack_require__(157);
+/* import */ var typeorm__rspack_import_4 = __webpack_require__(158);
+/* import */ var _config_index_js__rspack_import_10 = __webpack_require__(769);
+/* import */ var _config_index_js__rspack_import_11 = __webpack_require__(137);
+/* import */ var _dtos_form_result_dto_js__rspack_import_5 = __webpack_require__(788);
+/* import */ var _entities_index_js__rspack_import_6 = __webpack_require__(532);
+/* import */ var _enums_form_access_type_enum_js__rspack_import_12 = __webpack_require__(376);
+/* import */ var _utils_computed_field_utils_js__rspack_import_13 = __webpack_require__(801);
+/* import */ var _utils_permission_utils_js__rspack_import_7 = __webpack_require__(988);
+/* import */ var _form_builder_config_service_js__rspack_import_8 = __webpack_require__(781);
+/* import */ var _form_builder_datasource_provider_js__rspack_import_9 = __webpack_require__(593);
+function _ts_decorate(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;
+}
+function _ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+class FormResultService extends _flusys_nestjs_shared_classes__rspack_import_0.ApiService {
+    cacheManager;
+    utilsService;
+    formBuilderConfig;
+    dataSourceProvider;
+    formRepository = null;
+    constructor(cacheManager, utilsService, formBuilderConfig, dataSourceProvider){
+        super(_config_index_js__rspack_import_10/* .FORM_BUILDER_EVENT_ENTITIES.FORM_RESULT */.eF.FORM_RESULT, cacheManager, utilsService, FormResultService.name, true, _config_index_js__rspack_import_10/* .FORM_BUILDER_EVENT_MODULE */.T$, dataSourceProvider, _entities_index_js__rspack_import_6/* .FormResult */.ez), this.cacheManager = cacheManager, this.utilsService = utilsService, this.formBuilderConfig = formBuilderConfig, this.dataSourceProvider = dataSourceProvider;
+    }
+    async ensureFormRepositoryInitialized() {
+        if (!this.formRepository) {
+            const enableCompanyFeature = this.formBuilderConfig.isCompanyFeatureEnabled();
+            const formEntity = enableCompanyFeature ? _entities_index_js__rspack_import_6/* .FormWithCompany */.Wl : _entities_index_js__rspack_import_6/* .Form */.lV;
+            this.formRepository = await this.dataSourceProvider.getRepository(formEntity);
+        }
+    }
+    async getActiveForm(formId) {
+        await this.ensureFormRepositoryInitialized();
+        const form = await this.formRepository.findOne({
+            where: {
+                id: formId,
+                isActive: true,
+                deletedAt: (0,typeorm__rspack_import_4.IsNull)()
+            }
+        });
+        if (!form) {
+            throw new _nestjs_common__rspack_import_3.NotFoundException({
+                message: 'Form not found or inactive',
+                messageKey: _config_index_js__rspack_import_11/* .FORM_MESSAGES.NOT_FOUND */.Q.NOT_FOUND
+            });
+        }
+        return form;
+    }
+    applyCompanyFilterToQuery(query, user) {
+        if (this.formBuilderConfig.isCompanyFeatureEnabled() && user?.companyId) {
+            query.innerJoin('form', 'f', 'f.id = form_result.formId').andWhere('f.company_id = :companyId', {
+                companyId: user.companyId
+            });
+        }
+    }
+    async validateSubmissionAccess(form, user, isPublic) {
+        if (isPublic) {
+            if (form.accessType !== _enums_form_access_type_enum_js__rspack_import_12/* .FormAccessType.PUBLIC */.h.PUBLIC) {
+                throw new _nestjs_common__rspack_import_3.UnauthorizedException({
+                    message: 'This form is not available for public submission',
+                    messageKey: _config_index_js__rspack_import_11/* .FORM_MESSAGES.NOT_PUBLIC */.Q.NOT_PUBLIC
+                });
+            }
+            return;
+        }
+        if (form.accessType === _enums_form_access_type_enum_js__rspack_import_12/* .FormAccessType.PUBLIC */.h.PUBLIC) return;
+        if (!user) {
+            throw new _nestjs_common__rspack_import_3.UnauthorizedException({
+                message: 'Authentication required to submit this form',
+                messageKey: _config_index_js__rspack_import_11/* .FORM_MESSAGES.AUTH_REQUIRED */.Q.AUTH_REQUIRED
+            });
+        }
+        if (form.accessType === _enums_form_access_type_enum_js__rspack_import_12/* .FormAccessType.ACTION_GROUP */.h.ACTION_GROUP && form.actionGroups?.length) {
+            const hasPermission = await (0,_utils_permission_utils_js__rspack_import_7/* .validateUserPermissions */.i)(user, form.actionGroups, this.cacheManager, this.formBuilderConfig.isCompanyFeatureEnabled());
+            if (!hasPermission) {
+                throw new _nestjs_common__rspack_import_3.ForbiddenException({
+                    message: 'You do not have permission to submit this form',
+                    messageKey: _config_index_js__rspack_import_11/* .FORM_MESSAGES.ACCESS_DENIED */.Q.ACCESS_DENIED
+                });
+            }
+        } else if (form.accessType !== _enums_form_access_type_enum_js__rspack_import_12/* .FormAccessType.AUTHENTICATED */.h.AUTHENTICATED) {
+            throw new _nestjs_common__rspack_import_3.BadRequestException({
+                message: 'Invalid form access type',
+                messageKey: _config_index_js__rspack_import_11/* .FORM_MESSAGES.INVALID_ACCESS_TYPE */.Q.INVALID_ACCESS_TYPE
+            });
+        }
+    }
+    buildUserDraftWhere(formId, userId) {
+        return {
+            formId,
+            submittedById: userId,
+            isDraft: true,
+            deletedAt: (0,typeorm__rspack_import_4.IsNull)()
+        };
+    }
+    // Query Customization
+    async getSelectQuery(query, _user, select) {
+        if (!select || !select.length) {
+            select = [
+                'id',
+                'formId',
+                'schemaVersionSnapshot',
+                'schemaVersion',
+                'data',
+                'submittedById',
+                'submittedAt',
+                'isDraft',
+                'createdAt',
+                'updatedAt'
+            ];
+        }
+        const selectFields = select.map((field)=>`${this.entityName}.${field}`);
+        query.select(selectFields);
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    async getExtraManipulateQuery(query, filterDto, user) {
+        const result = await super.getExtraManipulateQuery(query, filterDto, user);
+        this.applyCompanyFilterToQuery(query, user);
+        return result;
+    }
+    applyComputedFields(data, form, isDraft) {
+        if (isDraft) {
+            return data;
+        }
+        const schema = form.schema;
+        const settings = schema?.settings;
+        const computedFields = settings?.computedFields;
+        if (!computedFields || computedFields.length === 0) {
+            return data;
+        }
+        const computedValues = (0,_utils_computed_field_utils_js__rspack_import_13/* .calculateComputedFields */.X)(data, computedFields);
+        return {
+            ...data,
+            _computed: computedValues
+        };
+    }
+    convertEntityToResponseDto(entity, _isRaw) {
+        return {
+            id: entity.id,
+            formId: entity.formId,
+            schemaVersionSnapshot: entity.schemaVersionSnapshot,
+            schemaVersion: entity.schemaVersion,
+            data: entity.data,
+            submittedById: entity.submittedById,
+            submittedAt: entity.submittedAt,
+            isDraft: entity.isDraft,
+            createdAt: entity.createdAt,
+            updatedAt: entity.updatedAt,
+            deletedAt: entity.deletedAt,
+            createdById: entity.createdById,
+            updatedById: entity.updatedById,
+            deletedById: entity.deletedById
+        };
+    }
+    // Form Submission
+    async submitForm(dto, user, isPublic = false) {
+        await this.ensureDataSourceRepository();
+        const form = await this.getActiveForm(dto.formId);
+        await this.validateSubmissionAccess(form, user, isPublic);
+        const isDraft = dto.isDraft ?? false;
+        const staleResults = [];
+        // Handle existing draft for authenticated users
+        if (user?.id) {
+            const existingDraft = await this.repository.findOne({
+                where: this.buildUserDraftWhere(dto.formId, user.id)
+            });
+            if (existingDraft) {
+                if (isDraft) {
+                    Object.assign(existingDraft, {
+                        data: dto.data,
+                        schemaVersionSnapshot: form.schema,
+                        schemaVersion: form.schemaVersion,
+                        submittedAt: new Date()
+                    });
+                    const saved = await this.repository.save(existingDraft);
+                    await this.invalidateResultCache([
+                        saved
+                    ]);
+                    await this.publishSubmissionEvent(saved, dto.formId, true, user);
+                    return this.convertEntityToResponseDto(saved, false);
+                }
+                await this.repository.softRemove(existingDraft);
+                staleResults.push(existingDraft);
+            }
+        }
+        const saved = await this.repository.save({
+            formId: dto.formId,
+            schemaVersionSnapshot: form.schema,
+            schemaVersion: form.schemaVersion,
+            data: this.applyComputedFields(dto.data, form, isDraft),
+            submittedById: user?.id ?? null,
+            submittedAt: new Date(),
+            isDraft
+        });
+        await this.invalidateResultCache([
+            ...staleResults,
+            saved
+        ]);
+        await this.publishSubmissionEvent(saved, dto.formId, isDraft, user);
+        return this.convertEntityToResponseDto(saved, false);
+    }
+    async getMyDraft(formId, user) {
+        await this.ensureDataSourceRepository();
+        const draft = await this.repository.findOne({
+            where: this.buildUserDraftWhere(formId, user.id),
+            order: {
+                updatedAt: 'DESC'
+            }
+        });
+        return draft ? this.convertEntityToResponseDto(draft, false) : null;
+    }
+    async updateDraft(draftId, dto, user) {
+        await this.ensureDataSourceRepository();
+        const draft = await this.repository.findOne({
+            where: {
+                id: draftId,
+                submittedById: user.id,
+                deletedAt: (0,typeorm__rspack_import_4.IsNull)()
+            }
+        });
+        if (!draft) {
+            throw new _nestjs_common__rspack_import_3.NotFoundException({
+                message: 'Draft not found',
+                messageKey: _config_index_js__rspack_import_11/* .FORM_RESULT_MESSAGES.NOT_FOUND */.y.NOT_FOUND
+            });
+        }
+        const form = await this.getActiveForm(dto.formId);
+        const isDraft = dto.isDraft ?? false;
+        Object.assign(draft, {
+            data: this.applyComputedFields(dto.data, form, isDraft),
+            schemaVersionSnapshot: form.schema,
+            schemaVersion: form.schemaVersion,
+            submittedAt: new Date(),
+            isDraft
+        });
+        const saved = await this.repository.save(draft);
+        await this.invalidateResultCache([
+            saved
+        ]);
+        await this.publishSubmissionEvent(saved, dto.formId, isDraft, user);
+        return this.convertEntityToResponseDto(saved, false);
+    }
+    async publishSubmissionEvent(result, formId, isDraft, user) {
+        await this.publishDomainAction(isDraft ? _config_index_js__rspack_import_10/* .FORM_BUILDER_EVENT_ACTIONS.DRAFT_SAVED */.ov.DRAFT_SAVED : _config_index_js__rspack_import_10/* .FORM_BUILDER_EVENT_ACTIONS.SUBMITTED */.ov.SUBMITTED, {
+            ids: [
+                result.id
+            ],
+            data: result,
+            metadata: {
+                formId,
+                isDraft,
+                schemaVersion: result.schemaVersion
+            },
+            user
+        });
+    }
+    async invalidateResultCache(results) {
+        await Promise.all([
+            this.clearCacheForAll(),
+            this.clearCacheForId(results)
+        ]);
+    }
+    async getByFormId(formId, user, pagination) {
+        await this.ensureDataSourceRepository();
+        const query = this.repository.createQueryBuilder(this.entityName).where('form_result.formId = :formId', {
+            formId
+        }).andWhere('form_result.deletedAt IS NULL');
+        this.applyCompanyFilterToQuery(query, user);
+        const page = pagination?.page ?? 0;
+        const pageSize = pagination?.pageSize ?? 10;
+        query.skip(page * pageSize).take(pageSize).orderBy('form_result.submittedAt', 'DESC');
+        const [entities, total] = await query.getManyAndCount();
+        return {
+            data: entities.map((e)=>this.convertEntityToResponseDto(e, false)),
+            total
+        };
+    }
+    async hasUserSubmitted(formId, user) {
+        await this.ensureDataSourceRepository();
+        const count = await this.repository.count({
+            where: {
+                formId,
+                submittedById: user.id,
+                isDraft: false,
+                deletedAt: (0,typeorm__rspack_import_4.IsNull)()
+            }
+        });
+        return count > 0;
+    }
+}
+_ts_decorate([
+    (0,_flusys_nestjs_shared_decorators__rspack_import_1.LogAction)({
+        action: 'formResult.submit',
+        module: 'form-builder'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _dtos_form_result_dto_js__rspack_import_5/* .SubmitFormDto */.sH === "undefined" ? Object : _dtos_form_result_dto_js__rspack_import_5/* .SubmitFormDto */.sH,
+        Object,
+        void 0
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], FormResultService.prototype, "submitForm", null);
+_ts_decorate([
+    (0,_flusys_nestjs_shared_decorators__rspack_import_1.LogAction)({
+        action: 'formResult.updateDraft',
+        module: 'form-builder'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        typeof _dtos_form_result_dto_js__rspack_import_5/* .SubmitFormDto */.sH === "undefined" ? Object : _dtos_form_result_dto_js__rspack_import_5/* .SubmitFormDto */.sH,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], FormResultService.prototype, "updateDraft", null);
+FormResultService = _ts_decorate([
+    (0,_nestjs_common__rspack_import_3.Injectable)({
+        scope: _nestjs_common__rspack_import_3.Scope.REQUEST
+    }),
+    _ts_param(0, (0,_nestjs_common__rspack_import_3.Inject)('CACHE_INSTANCE')),
+    _ts_param(1, (0,_nestjs_common__rspack_import_3.Inject)(_flusys_nestjs_shared_modules__rspack_import_2.UtilsService)),
+    _ts_param(2, (0,_nestjs_common__rspack_import_3.Inject)(_form_builder_config_service_js__rspack_import_8/* .FormBuilderConfigService */.j)),
+    _ts_param(3, (0,_nestjs_common__rspack_import_3.Inject)(_form_builder_datasource_provider_js__rspack_import_9/* .FormBuilderDataSourceProvider */._)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _flusys_nestjs_shared_classes__rspack_import_0.HybridCache === "undefined" ? Object : _flusys_nestjs_shared_classes__rspack_import_0.HybridCache,
+        typeof _flusys_nestjs_shared_modules__rspack_import_2.UtilsService === "undefined" ? Object : _flusys_nestjs_shared_modules__rspack_import_2.UtilsService,
+        typeof _form_builder_config_service_js__rspack_import_8/* .FormBuilderConfigService */.j === "undefined" ? Object : _form_builder_config_service_js__rspack_import_8/* .FormBuilderConfigService */.j,
+        typeof _form_builder_datasource_provider_js__rspack_import_9/* .FormBuilderDataSourceProvider */._ === "undefined" ? Object : _form_builder_datasource_provider_js__rspack_import_9/* .FormBuilderDataSourceProvider */._
+    ])
+], FormResultService);
+
+__webpack_require__.d(__webpack_exports__, {
+  v: () => (FormResultService)
+});
+
+
+},
+148(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  u: () => (/* binding */ FormService)
+});
+
+;// CONCATENATED MODULE: external "@flusys/nestjs-core"
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/classes"
+var classes_ = __webpack_require__(937);
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/modules"
+var modules_ = __webpack_require__(236);
+;// CONCATENATED MODULE: external "@flusys/nestjs-shared/utils"
+
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(157);
+// EXTERNAL MODULE: external "typeorm"
+var external_typeorm_ = __webpack_require__(158);
+// EXTERNAL MODULE: ./projects/nestjs-form-builder/src/config/event-actions.ts
+var event_actions = __webpack_require__(769);
+// EXTERNAL MODULE: ./projects/nestjs-form-builder/src/config/message-keys.ts
+var message_keys = __webpack_require__(137);
+// EXTERNAL MODULE: ./projects/nestjs-form-builder/src/entities/index.ts + 5 modules
+var entities = __webpack_require__(532);
+// EXTERNAL MODULE: ./projects/nestjs-form-builder/src/enums/form-access-type.enum.ts
+var form_access_type_enum = __webpack_require__(376);
+// EXTERNAL MODULE: ./projects/nestjs-form-builder/src/utils/permission.utils.ts
+var permission_utils = __webpack_require__(988);
+// EXTERNAL MODULE: ./projects/nestjs-form-builder/src/services/form-builder-config.service.ts
+var form_builder_config_service = __webpack_require__(781);
+// EXTERNAL MODULE: ./projects/nestjs-form-builder/src/services/form-builder-datasource.provider.ts + 1 modules
+var form_builder_datasource_provider = __webpack_require__(593);
+;// CONCATENATED MODULE: ./projects/nestjs-form-builder/src/services/form.service.ts
+function _ts_decorate(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;
+}
+function _ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+class FormService extends classes_.ApiService {
+    cacheManager;
+    utilsService;
+    formBuilderConfig;
+    constructor(cacheManager, utilsService, formBuilderConfig, dataSourceProvider){
+        super(event_actions/* .FORM_BUILDER_EVENT_ENTITIES.FORM */.eF.FORM, cacheManager, utilsService, FormService.name, true, event_actions/* .FORM_BUILDER_EVENT_MODULE */.T$, dataSourceProvider, formBuilderConfig.isCompanyFeatureEnabled() ? entities/* .FormWithCompany */.Wl : entities/* .Form */.lV), this.cacheManager = cacheManager, this.utilsService = utilsService, this.formBuilderConfig = formBuilderConfig;
+    }
+    // Entity Conversion
+    async convertSingleDtoToEntity(dto, user) {
+        let form = {};
+        let isUpdate = false;
+        // NOTE: Using 'id' in dto check instead of instanceof - instanceof may not work after esbuild bundling
+        if ('id' in dto && dto.id && typeof dto.id === 'string') {
+            const dbData = await this.repository.findOne({
+                where: {
+                    id: dto.id
+                }
+            });
+            if (!dbData) {
+                throw new common_.NotFoundException({
+                    message: 'Form not found',
+                    messageKey: message_keys/* .FORM_MESSAGES.NOT_FOUND */.Q.NOT_FOUND
+                });
+            }
+            form = dbData;
+            isUpdate = true;
+            // Auto-increment schema version if schema changed
+            if (dto.schema && JSON.stringify(dto.schema) !== JSON.stringify(form.schema)) {
+                dto.schemaVersion = form.schemaVersion + 1;
+            }
+        }
+        // Merge DTO into form
+        form = {
+            ...form,
+            ...dto
+        };
+        // Set company context if enabled
+        const enableCompanyFeature = this.formBuilderConfig.isCompanyFeatureEnabled();
+        if (enableCompanyFeature) {
+            if (isUpdate) {
+                // During update: Only set companyId if explicitly provided
+                if (dto.companyId !== undefined) {
+                    form.companyId = dto.companyId;
+                }
+                // If companyId is not in form at all, set from user
+                if (form.companyId === undefined) {
+                    form.companyId = user?.companyId ?? null;
+                }
+            } else {
+                // During creation: Use DTO's companyId if provided, otherwise use user's
+                form.companyId = dto.companyId ?? user?.companyId ?? null;
+            }
+        }
+        return form;
+    }
+    async getSelectQuery(query, _user, select) {
+        if (!select || !select.length) {
+            select = [
+                'id',
+                'name',
+                'description',
+                'slug',
+                'schema',
+                'schemaVersion',
+                'accessType',
+                'actionGroups',
+                'tags',
+                'isActive',
+                'createdAt',
+                'updatedAt'
+            ];
+        }
+        const selectFields = select.map((field)=>`${this.entityName}.${field}`);
+        // Add company context fields if company feature is enabled
+        if (this.formBuilderConfig.isCompanyFeatureEnabled()) {
+            selectFields.push('form.companyId');
+        }
+        query.select(selectFields);
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    // Supports filtering by one or more tags (array-contains-all) via the generic get-all filter,
+    // e.g. { filter: { tags: ['survey', 'review'] } }, since tags is a JSON array column.
+    async getFilterQuery(query, filter, user) {
+        const { tags, ...rest } = filter;
+        if (tags !== undefined && tags !== null) {
+            const tagList = (Array.isArray(tags) ? tags : [
+                tags
+            ]).map(String);
+            if (tagList.length > 0) {
+                this.applyTagFilter(query, tagList);
+            }
+        }
+        return super.getFilterQuery(query, rest, user);
+    }
+    applyTagFilter(query, tags) {
+        const driver = __rspack_external__flusys_nestjs_core_ff4ca4e2.envConfig.getTypeOrmConfig().type;
+        if (driver === 'postgres') {
+            query.andWhere(`${this.entityName}.tags @> :tagValues::jsonb`, {
+                tagValues: JSON.stringify(tags)
+            });
+        } else if (driver === 'mysql') {
+            query.andWhere(`JSON_CONTAINS(${this.entityName}.tags, :tagValues)`, {
+                tagValues: JSON.stringify(tags)
+            });
+        } else {
+            tags.forEach((tag, index)=>{
+                query.andWhere(`${this.entityName}.tags LIKE :tagValue${index}`, {
+                    [`tagValue${index}`]: `%"${tag}"%`
+                });
+            });
+        }
+    }
+    async getExtraManipulateQuery(query, filterDto, user) {
+        const result = await super.getExtraManipulateQuery(query, filterDto, user);
+        // Apply company filter using shared utility
+        (0,__rspack_external__flusys_nestjs_shared_utils_9125c1f1.applyCompanyFilter)(query, {
+            isCompanyFeatureEnabled: this.formBuilderConfig.isCompanyFeatureEnabled(),
+            entityAlias: 'form'
+        }, user);
+        return result;
+    }
+    convertEntityToResponseDto(entity, _isRaw) {
+        // Type guard for company-enabled entity
+        const entityWithCompany = entity;
+        return {
+            id: entity.id,
+            name: entity.name,
+            description: entity.description,
+            slug: entity.slug,
+            schema: entity.schema,
+            schemaVersion: entity.schemaVersion,
+            accessType: entity.accessType,
+            actionGroups: entity.actionGroups,
+            tags: entity.tags,
+            isActive: entity.isActive,
+            companyId: entityWithCompany.companyId ?? null,
+            createdAt: entity.createdAt,
+            updatedAt: entity.updatedAt,
+            deletedAt: entity.deletedAt,
+            createdById: entity.createdById,
+            updatedById: entity.updatedById,
+            deletedById: entity.deletedById
+        };
+    }
+    toPublicForm(form) {
+        return {
+            id: form.id,
+            name: form.name,
+            description: form.description,
+            schema: form.schema,
+            schemaVersion: form.schemaVersion
+        };
+    }
+    async findPublicActiveForm(where) {
+        await this.ensureDataSourceRepository();
+        return await this.repository.findOne({
+            where: {
+                ...where,
+                accessType: form_access_type_enum/* .FormAccessType.PUBLIC */.h.PUBLIC,
+                isActive: true,
+                deletedAt: (0,external_typeorm_.IsNull)()
+            }
+        });
+    }
+    // Public Form Access
+    async getPublicForm(formId) {
+        const form = await this.findPublicActiveForm({
+            id: formId
+        });
+        if (!form) {
+            throw new common_.NotFoundException({
+                message: 'Form not found or not available for public access',
+                messageKey: message_keys/* .FORM_MESSAGES.NOT_PUBLIC */.Q.NOT_PUBLIC
+            });
+        }
+        return this.toPublicForm(form);
+    }
+    async getFormForSubmission(formId, user) {
+        await this.ensureDataSourceRepository();
+        const form = await this.repository.findOne({
+            where: {
+                id: formId,
+                isActive: true,
+                deletedAt: (0,external_typeorm_.IsNull)()
+            }
+        });
+        if (!form) {
+            throw new common_.NotFoundException({
+                message: 'Form not found or inactive',
+                messageKey: message_keys/* .FORM_MESSAGES.NOT_FOUND */.Q.NOT_FOUND
+            });
+        }
+        // Access validation based on accessType
+        if (form.accessType === form_access_type_enum/* .FormAccessType.PUBLIC */.h.PUBLIC) {
+            return form; // Anyone can access
+        }
+        // All non-public forms require authentication
+        if (!user) {
+            throw new common_.UnauthorizedException({
+                message: 'Authentication required to submit this form',
+                messageKey: message_keys/* .FORM_MESSAGES.AUTH_REQUIRED */.Q.AUTH_REQUIRED
+            });
+        }
+        if (form.accessType === form_access_type_enum/* .FormAccessType.AUTHENTICATED */.h.AUTHENTICATED || form.accessType === form_access_type_enum/* .FormAccessType.ACTION_GROUP */.h.ACTION_GROUP) {
+            return form; // Permission check for ACTION_GROUP is handled by the controller/guard
+        }
+        throw new common_.BadRequestException({
+            message: 'Invalid access type',
+            messageKey: message_keys/* .FORM_MESSAGES.INVALID_ACCESS_TYPE */.Q.INVALID_ACCESS_TYPE
+        });
+    }
+    async getBySlug(slug) {
+        await this.ensureDataSourceRepository();
+        const form = await this.repository.findOne({
+            where: {
+                slug,
+                deletedAt: (0,external_typeorm_.IsNull)()
+            }
+        });
+        return form ? this.convertEntityToResponseDto(form, false) : null;
+    }
+    /**
+   * Get public form by slug (no authentication required)
+   * Returns null if form doesn't exist, is not public, or is inactive
+   */ async getPublicFormBySlug(slug) {
+        const form = await this.findPublicActiveForm({
+            slug
+        });
+        return form ? this.toPublicForm(form) : null;
+    }
+    async getFormAccessInfo(formId) {
+        await this.ensureDataSourceRepository();
+        const form = await this.repository.findOne({
+            where: {
+                id: formId,
+                deletedAt: (0,external_typeorm_.IsNull)()
+            },
+            select: [
+                'id',
+                'name',
+                'description',
+                'accessType',
+                'actionGroups',
+                'isActive'
+            ]
+        });
+        if (!form) {
+            throw new common_.NotFoundException({
+                message: 'Form not found',
+                messageKey: message_keys/* .FORM_MESSAGES.NOT_FOUND */.Q.NOT_FOUND
+            });
+        }
+        return {
+            id: form.id,
+            name: form.name,
+            description: form.description,
+            accessType: form.accessType,
+            actionGroups: form.actionGroups,
+            isActive: form.isActive
+        };
+    }
+    async getAuthenticatedForm(formId, user) {
+        const form = await this.getFormForSubmission(formId, user);
+        // For action_group access, check permissions from cache
+        if (form.accessType === form_access_type_enum/* .FormAccessType.ACTION_GROUP */.h.ACTION_GROUP && form.actionGroups?.length) {
+            const hasPermission = await (0,permission_utils/* .validateUserPermissions */.i)(user, form.actionGroups, this.cacheManager, this.formBuilderConfig.isCompanyFeatureEnabled());
+            if (!hasPermission) {
+                throw new common_.ForbiddenException({
+                    message: 'You do not have permission to access this form',
+                    messageKey: message_keys/* .FORM_MESSAGES.ACCESS_DENIED */.Q.ACCESS_DENIED
+                });
+            }
+        }
+        return this.toPublicForm(form);
+    }
+}
+FormService = _ts_decorate([
+    (0,common_.Injectable)({
+        scope: common_.Scope.REQUEST
+    }),
+    _ts_param(0, (0,common_.Inject)('CACHE_INSTANCE')),
+    _ts_param(1, (0,common_.Inject)(modules_.UtilsService)),
+    _ts_param(2, (0,common_.Inject)(form_builder_config_service/* .FormBuilderConfigService */.j)),
+    _ts_param(3, (0,common_.Inject)(form_builder_datasource_provider/* .FormBuilderDataSourceProvider */._)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof classes_.HybridCache === "undefined" ? Object : classes_.HybridCache,
+        typeof modules_.UtilsService === "undefined" ? Object : modules_.UtilsService,
+        typeof form_builder_config_service/* .FormBuilderConfigService */.j === "undefined" ? Object : form_builder_config_service/* .FormBuilderConfigService */.j,
+        typeof form_builder_datasource_provider/* .FormBuilderDataSourceProvider */._ === "undefined" ? Object : form_builder_datasource_provider/* .FormBuilderDataSourceProvider */._
+    ])
+], FormService);
+
+
+},
+801(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/**
+ * Computed Field Calculation Utilities
+ *
+ * This module provides functions to calculate computed field values
+ * based on form submission data and computed field definitions.
+ *
+ * NOTE: Interface definitions here mirror @flusys/ng-form-builder interfaces
+ * but are defined separately to avoid cross-package dependencies.
+ * Both use compatible JSON structures for form schema serialization.
+ *
+ * @see FLUSYS_NG/projects/ng-form-builder/interfaces/computed-field.interface.ts
+ */ // ============================================================================
+// Type Definitions
+// ============================================================================
+// ============================================================================
+// Type Guards & Helpers
+// ============================================================================
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isDirectValueConfig(config) {
+    return isObject(config) && config.type === 'direct' && 'value' in config;
+}
+function isFieldReferenceConfig(config) {
+    return isObject(config) && config.type === 'field_reference' && 'fieldId' in config;
+}
+function isArithmeticConfig(config) {
+    return isObject(config) && config.type === 'arithmetic' && 'operation' in config && 'operands' in config && Array.isArray(config.operands);
+}
+function isEmptyValue(value) {
+    return value === null || value === undefined || value === '' || Array.isArray(value) && value.length === 0;
+}
+/**
+ * Normalize operator to uppercase string (handles both enum and string values)
+ */ function normalizeOperator(op) {
+    const strOp = String(op).toUpperCase();
+    return strOp === 'OR' ? 'OR' : 'AND';
+}
+/**
+ * Calculate all computed fields for a form submission
+ *
+ * @param formData - The submitted form data (field values by field ID)
+ * @param computedFields - Array of computed field definitions from form settings
+ * @returns Object containing computed field values keyed by their key property
+ */ function calculateComputedFields(formData, computedFields) {
+    if (!computedFields || computedFields.length === 0) {
+        return {};
+    }
+    const result = {};
+    for (const field of computedFields){
+        try {
+            const value = calculateComputedField(formData, field);
+            result[field.key] = value;
+        } catch (error) {
+            // If calculation fails, use default value or null
+            result[field.key] = field.defaultValue ?? null;
+        }
+    }
+    return result;
+}
+/**
+ * Calculate a single computed field value
+ */ function calculateComputedField(formData, field) {
+    // Evaluate rules in order, first matching rule wins
+    for (const rule of field.rules){
+        if (evaluateCondition(formData, rule.condition)) {
+            return executeComputation(formData, rule.computation, field.valueType);
+        }
+    }
+    // No rule matched, return default
+    return field.defaultValue ?? null;
+}
+/**
+ * Evaluate a condition group
+ */ function evaluateCondition(formData, conditionGroup) {
+    // No condition = always true
+    if (!conditionGroup || !conditionGroup.conditions || conditionGroup.conditions.length === 0) {
+        return true;
+    }
+    const results = conditionGroup.conditions.map((condition)=>evaluateSingleCondition(formData, condition));
+    // Normalize operator to handle both string and enum values
+    const operator = normalizeOperator(conditionGroup.operator);
+    if (operator === 'AND') {
+        return results.every((r)=>r);
+    } else {
+        return results.some((r)=>r);
+    }
+}
+/**
+ * Evaluate a single condition
+ */ function evaluateSingleCondition(formData, condition) {
+    const fieldValue = formData[condition.fieldId];
+    const compareValue = condition.value;
+    switch(condition.comparison){
+        case 'equals':
+            return fieldValue === compareValue || String(fieldValue) === String(compareValue);
+        case 'not_equals':
+            return fieldValue !== compareValue && String(fieldValue) !== String(compareValue);
+        case 'is_empty':
+            return isEmptyValue(fieldValue);
+        case 'is_not_empty':
+            return !isEmptyValue(fieldValue);
+        case 'contains':
+            return String(fieldValue).includes(String(compareValue));
+        case 'not_contains':
+            return !String(fieldValue).includes(String(compareValue));
+        case 'starts_with':
+            return String(fieldValue).startsWith(String(compareValue));
+        case 'ends_with':
+            return String(fieldValue).endsWith(String(compareValue));
+        case 'greater_than':
+            return Number(fieldValue) > Number(compareValue);
+        case 'less_than':
+            return Number(fieldValue) < Number(compareValue);
+        case 'greater_or_equal':
+            return Number(fieldValue) >= Number(compareValue);
+        case 'less_or_equal':
+            return Number(fieldValue) <= Number(compareValue);
+        case 'is_before':
+            return new Date(String(fieldValue)) < new Date(String(compareValue));
+        case 'is_after':
+            return new Date(String(fieldValue)) > new Date(String(compareValue));
+        case 'is_checked':
+            return fieldValue === true || fieldValue === 'true' || fieldValue === 1;
+        case 'is_not_checked':
+            return fieldValue === false || fieldValue === 'false' || fieldValue === 0 || !fieldValue;
+        case 'is_any_of':
+        case 'in':
+            return Array.isArray(compareValue) && compareValue.includes(fieldValue);
+        case 'is_none_of':
+        case 'not_in':
+            return !Array.isArray(compareValue) || !compareValue.includes(fieldValue);
+        default:
+            return false;
+    }
+}
+/**
+ * Execute a computation and return the result
+ */ function executeComputation(formData, computation, valueType) {
+    const { config } = computation;
+    // Use type guards for safe access
+    if (computation.type === 'direct' && isDirectValueConfig(config)) {
+        return valueType === 'number' ? Number(config.value) : String(config.value);
+    }
+    if (computation.type === 'field_reference' && isFieldReferenceConfig(config)) {
+        const value = formData[config.fieldId];
+        if (value === null || value === undefined) {
+            return null;
+        }
+        return valueType === 'number' ? Number(value) : String(value);
+    }
+    if (computation.type === 'arithmetic' && isArithmeticConfig(config)) {
+        return calculateArithmetic(formData, config);
+    }
+    // Unknown computation type
+    return null;
+}
+/**
+ * Perform arithmetic calculation
+ */ function calculateArithmetic(formData, config) {
+    const values = config.operands.map((operand)=>{
+        if (operand.type === 'constant') {
+            return operand.value ?? 0;
+        } else {
+            const fieldValue = formData[operand.fieldId ?? ''];
+            return fieldValue !== null && fieldValue !== undefined ? Number(fieldValue) : 0;
+        }
+    });
+    if (values.length === 0) {
+        return null;
+    }
+    switch(config.operation){
+        case 'sum':
+        case 'increment':
+            return values.reduce((acc, val)=>acc + val, 0);
+        case 'subtract':
+        case 'decrement':
+            return values.reduce((acc, val, idx)=>idx === 0 ? val : acc - val, 0);
+        case 'multiply':
+            return values.reduce((acc, val)=>acc * val, 1);
+        case 'divide':
+            {
+                const [first, ...rest] = values;
+                return rest.reduce((acc, val)=>val !== 0 ? acc / val : acc, first);
+            }
+        case 'average':
+            return values.reduce((acc, val)=>acc + val, 0) / values.length;
+        case 'min':
+            return Math.min(...values);
+        case 'max':
+            return Math.max(...values);
+        default:
+            return null;
+    }
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  X: () => (calculateComputedFields)
+});
+
+
+},
+988(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _config_index_js__rspack_import_1 = __webpack_require__(137);
+/* import */ var _nestjs_common__rspack_import_0 = __webpack_require__(157);
+
+
+const CACHE_PREFIX = 'permissions';
+/**
+ * Build permission cache key for a user
+ * Uses same cache key format as PermissionGuard in nestjs-shared
+ */ function buildPermissionCacheKey(user, enableCompanyFeature) {
+    if (enableCompanyFeature && user.companyId) {
+        return `${CACHE_PREFIX}:company:${user.companyId}:branch:${user.branchId || 'null'}:user:${user.id}`;
+    }
+    return `${CACHE_PREFIX}:user:${user.id}`;
+}
+/**
+ * Get user permissions from cache
+ * Fail-closed: if cache fails, deny access rather than allowing potentially unauthorized access
+ */ async function getUserPermissionsFromCache(user, cacheManager, enableCompanyFeature) {
+    const cacheKey = buildPermissionCacheKey(user, enableCompanyFeature);
+    try {
+        const permissions = await cacheManager.get(cacheKey);
+        return permissions ?? [];
+    } catch  {
+        throw new _nestjs_common__rspack_import_0.ForbiddenException({
+            message: 'Unable to verify permissions. Please try again.',
+            messageKey: _config_index_js__rspack_import_1/* .FORM_MESSAGES.PERMISSION_CHECK_FAILED */.Q.PERMISSION_CHECK_FAILED
+        });
+    }
+}
+/**
+ * Validate user has at least one of the required permissions
+ *
+ * @param user - The logged-in user
+ * @param requiredPermissions - Array of required permission strings (user needs at least one)
+ * @param cacheManager - Cache manager instance
+ * @param enableCompanyFeature - Whether company feature is enabled
+ * @returns true if user has permission, false otherwise
+ */ async function validateUserPermissions(user, requiredPermissions, cacheManager, enableCompanyFeature) {
+    if (!requiredPermissions.length) {
+        return true;
+    }
+    const userPermissions = await getUserPermissionsFromCache(user, cacheManager, enableCompanyFeature);
+    return requiredPermissions.some((perm)=>userPermissions.includes(perm));
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  i: () => (validateUserPermissions)
+});
+
+
+},
+937(module) {
+
+module.exports = __rspack_external__flusys_nestjs_shared_classes_6076a329;
+
+
+},
+265(module) {
+
+module.exports = __rspack_external__flusys_nestjs_shared_decorators_c129b601;
+
+
+},
+873(module) {
+
+module.exports = __rspack_external__flusys_nestjs_shared_dtos_c4585026;
+
+
+},
+236(module) {
+
+module.exports = __rspack_external__flusys_nestjs_shared_modules_24702bee;
+
+
+},
+157(module) {
+
+module.exports = __rspack_external__nestjs_common_a04939da;
+
+
+},
+176(module) {
+
+module.exports = __rspack_external__nestjs_swagger_7cd450b5;
+
+
+},
+812(module) {
+
+module.exports = __rspack_external_class_transformer_c5a479fb;
+
+
+},
+421(module) {
+
+module.exports = __rspack_external_class_validator_7b99ef4d;
+
+
+},
+158(module) {
+
+module.exports = __rspack_external_typeorm;
+
+
+},
+
+};