@flusys/nestjs-entity-builder 9.1.0-rc.1

package/config/message-keys.d.ts

@@ -0,0 +1,481 @@
+export declare const ENTITY_DEFINITION_MESSAGES: {
+    readonly NOT_FOUND: "entity_builder.entity_definition.not.found";
+    readonly CODE_ALREADY_EXISTS: "entity_builder.entity_definition.code.already.exists";
+    readonly DEPRECATED: "entity_builder.entity_definition.deprecated";
+    readonly ID_REQUIRED: "entity_builder.entity_definition.id.required";
+    readonly INVALID_STATUS: "entity_builder.entity_definition.invalid.status";
+    readonly CREATE_SUCCESS: "entity_builder.entity_definition.create.success";
+    readonly GET_SUCCESS: "entity_builder.entity_definition.get.success";
+    readonly GET_BY_IDS_SUCCESS: "entity_builder.entity_definition.get.by.ids.success";
+    readonly GET_BY_FILTER_SUCCESS: "entity_builder.entity_definition.get.by.filter.success";
+    readonly GET_ALL_SUCCESS: "entity_builder.entity_definition.get.all.success";
+    readonly PLAN_SUCCESS: "entity_builder.entity_definition.plan.success";
+    readonly APPLY_SUCCESS: "entity_builder.entity_definition.apply.success";
+    readonly INSPECT_SUCCESS: "entity_builder.entity_definition.inspect.success";
+    readonly HISTORY_SUCCESS: "entity_builder.entity_definition.history.success";
+};
+export declare const FIELD_DEFINITION_MESSAGES: {
+    readonly NOT_FOUND: "entity_builder.field_definition.not.found";
+    readonly ID_REQUIRED: "entity_builder.field_definition.id.required";
+    readonly DEFINITION_REQUIRED: "entity_builder.field_definition.definition.required";
+    readonly DEPRECATED_LOCKED: "entity_builder.field_definition.deprecated.locked";
+    readonly RENAME_ALONE: "entity_builder.field_definition.rename.alone";
+    readonly GET_SUCCESS: "entity_builder.field_definition.get.success";
+    readonly GET_BY_IDS_SUCCESS: "entity_builder.field_definition.get.by.ids.success";
+    readonly GET_BY_FILTER_SUCCESS: "entity_builder.field_definition.get.by.filter.success";
+    readonly GET_ALL_SUCCESS: "entity_builder.field_definition.get.all.success";
+};
+export declare const FLOW_DEFINITION_MESSAGES: {
+    readonly CREATE_SUCCESS: "entity_builder.flow_definition.create.success";
+    readonly UPDATE_SUCCESS: "entity_builder.flow_definition.update.success";
+    readonly DELETE_SUCCESS: "entity_builder.flow_definition.delete.success";
+    readonly RESTORE_SUCCESS: "entity_builder.flow_definition.restore.success";
+    readonly GET_SUCCESS: "entity_builder.flow_definition.get.success";
+    readonly GET_BY_IDS_SUCCESS: "entity_builder.flow_definition.get.by.ids.success";
+    readonly GET_BY_FILTER_SUCCESS: "entity_builder.flow_definition.get.by.filter.success";
+    readonly GET_ALL_SUCCESS: "entity_builder.flow_definition.get.all.success";
+};
+export declare const GENERIC_RECORD_MESSAGES: {
+    readonly NOT_FOUND: "entity_builder.generic_record.not.found";
+    readonly NO_MATCH: "entity_builder.generic_record.no.match";
+    readonly ID_REQUIRED: "entity_builder.generic_record.id.required";
+    readonly UNKNOWN_FIELD: "entity_builder.generic_record.unknown.field";
+    readonly SYSTEM_COLUMN_READONLY: "entity_builder.generic_record.system.column.readonly";
+    readonly VALIDATION_FAILED: "entity_builder.generic_record.validation.failed";
+    readonly UNIQUE_VIOLATION: "entity_builder.generic_record.unique.violation";
+    readonly UNIQUE_VIOLATION_ANY: "entity_builder.generic_record.unique.violation.any";
+    readonly REQUIRED: "entity_builder.generic_record.required";
+    readonly REQUIRED_ANY: "entity_builder.generic_record.required.any";
+    readonly TOO_LONG: "entity_builder.generic_record.too.long";
+    readonly TOO_LONG_ANY: "entity_builder.generic_record.too.long.any";
+    readonly OUT_OF_RANGE: "entity_builder.generic_record.out.of.range";
+    readonly OUT_OF_RANGE_ANY: "entity_builder.generic_record.out.of.range.any";
+    readonly INVALID_FORMAT: "entity_builder.generic_record.invalid.format";
+    readonly INVALID_FORMAT_ANY: "entity_builder.generic_record.invalid.format.any";
+    readonly REFERENCE_VIOLATION: "entity_builder.generic_record.reference.violation";
+    readonly FILTER_OPERATOR_UNKNOWN: "entity_builder.generic_record.filter.operator.unknown";
+    readonly FILTER_VALUE_INVALID: "entity_builder.generic_record.filter.value.invalid";
+    readonly FILTER_TOO_MANY_VALUES: "entity_builder.generic_record.filter.too.many.values";
+};
+export declare const SCHEMA_MESSAGES: {
+    readonly BUSY: "entity_builder.schema.busy";
+    readonly COLUMN_EXISTS: "entity_builder.schema.column.exists";
+    readonly TABLE_EXISTS: "entity_builder.schema.table.exists";
+    readonly DRIFT_COLUMN: "entity_builder.schema.drift.column";
+    readonly DRIFT_TABLE: "entity_builder.schema.drift.table";
+    readonly CONVERSION_FAILED: "entity_builder.schema.conversion.failed";
+    readonly DUPLICATES_EXIST: "entity_builder.schema.duplicates.exist";
+    readonly NULLS_EXIST: "entity_builder.schema.nulls.exist";
+    readonly FAILED: "entity_builder.schema.failed";
+    readonly BLOCKED: "entity_builder.schema.blocked";
+    readonly NO_LONGER_APPLICABLE: "entity_builder.schema.no.longer.applicable";
+    readonly CONFIRMATION_REQUIRED: "entity_builder.schema.confirmation.required";
+    readonly USE_DESTRUCTIVE_ENDPOINT: "entity_builder.schema.use.destructive.endpoint";
+    readonly USE_REGULAR_ENDPOINT: "entity_builder.schema.use.regular.endpoint";
+    readonly UNSUPPORTED_FIELD_TYPE: "entity_builder.schema.unsupported.field.type";
+    readonly UNSUPPORTED_DRIVER: "entity_builder.schema.unsupported.driver";
+    readonly UNKNOWN_CHANGE_PROPERTY: "entity_builder.schema.unknown.change.property";
+    readonly DUPLICATE_FIELD_CODE: "entity_builder.schema.duplicate.field.code";
+    readonly INVALID_CODE_PATTERN: "entity_builder.schema.invalid.code.pattern";
+    readonly RESERVED_WORD: "entity_builder.schema.reserved.word";
+    readonly SYSTEM_COLUMN_CODE: "entity_builder.schema.system.column.code";
+    readonly NOT_INDEXABLE: "entity_builder.schema.not.indexable";
+    readonly INVALID_CHANGE_VALUE: "entity_builder.schema.invalid.change.value";
+    readonly STALE_DEFINITION: "entity_builder.schema.stale.definition";
+    readonly FAILED_NOT_REVERTED: "entity_builder.schema.failed.not.reverted";
+};
+export declare const SCHEMA_BLOCKER_MESSAGES: {
+    readonly TABLE_MISSING: "entity_builder.schema.blocker.table.missing";
+    readonly TABLE_EXISTS: "entity_builder.schema.blocker.table.exists";
+    readonly ENTITY_CODE_EXISTS: "entity_builder.schema.blocker.entity.code.exists";
+    readonly RELATION_FIELD_TARGET_MISSING: "entity_builder.schema.blocker.relation.field.target.missing";
+    readonly FLOW_SLUG_TAKEN: "entity_builder.schema.blocker.flow.slug.taken";
+    readonly RELATION_TARGET_MISSING: "entity_builder.schema.blocker.relation.target.missing";
+    readonly RELATION_TARGET_REQUIRED: "entity_builder.schema.blocker.relation.target.required";
+    readonly FIELD_EXISTS: "entity_builder.schema.blocker.field.exists";
+    readonly FIELD_EXISTS_DEPRECATED: "entity_builder.schema.blocker.field.exists.deprecated";
+    readonly DEFAULT_INVALID: "entity_builder.schema.blocker.default.invalid";
+    readonly BACKFILL_INVALID: "entity_builder.schema.blocker.backfill.invalid";
+    readonly REQUIRED_NEEDS_VALUE: "entity_builder.schema.blocker.required.needs.value";
+    readonly UNIQUE_BACKFILL_CONFLICT: "entity_builder.schema.blocker.unique.backfill.conflict";
+    readonly COLUMN_MISSING: "entity_builder.schema.blocker.column.missing";
+    readonly CONVERSION_UNSUPPORTED: "entity_builder.schema.blocker.conversion.unsupported";
+    readonly CONVERSION_BAD_ROWS: "entity_builder.schema.blocker.conversion.bad.rows";
+    readonly CURRENT_DEFAULT_INVALID: "entity_builder.schema.blocker.current.default.invalid";
+    readonly NULLS_NEED_VALUE: "entity_builder.schema.blocker.nulls.need.value";
+    readonly DUPLICATE_VALUES: "entity_builder.schema.blocker.duplicate.values";
+    readonly FIELD_CODE_TAKEN: "entity_builder.schema.blocker.field.code.taken";
+    readonly FIELD_CODE_TAKEN_DEPRECATED: "entity_builder.schema.blocker.field.code.taken.deprecated";
+    readonly RENAME_IN_USE: "entity_builder.schema.blocker.rename.in.use";
+    readonly ALREADY_DEPRECATED: "entity_builder.schema.blocker.already.deprecated";
+    readonly NOT_DEPRECATED: "entity_builder.schema.blocker.not.deprecated";
+    readonly COLUMN_GONE: "entity_builder.schema.blocker.column.gone";
+    readonly PURGE_REQUIRES_DEPRECATED: "entity_builder.schema.blocker.purge.requires.deprecated";
+    readonly PURGE_CONFIRM_CODE: "entity_builder.schema.blocker.purge.confirm.code";
+    readonly PURGE_IN_USE: "entity_builder.schema.blocker.purge.in.use";
+    readonly DROP_CONFIRM_CODE: "entity_builder.schema.blocker.drop.confirm.code";
+    readonly DROP_IN_USE: "entity_builder.schema.blocker.drop.in.use";
+    readonly DROP_RELATION_IN_USE: "entity_builder.schema.blocker.drop.relation.in.use";
+    readonly DEFINITION_CHANGED: "entity_builder.schema.blocker.definition.changed";
+};
+export declare const SCHEMA_WARNING_MESSAGES: {
+    readonly NO_SELECT_OPTIONS_YET: "entity_builder.schema.warning.no.select.options.yet";
+    readonly NO_SELECT_OPTIONS_CONVERT: "entity_builder.schema.warning.no.select.options.convert";
+    readonly STRAY_VALUES: "entity_builder.schema.warning.stray.values";
+    readonly RULES_VIOLATED: "entity_builder.schema.warning.rules.violated";
+    readonly LOSSY_ROUNDING: "entity_builder.schema.warning.lossy.rounding";
+    readonly LOSSY_TIME_DROPPED: "entity_builder.schema.warning.lossy.time.dropped";
+    readonly BACKFILL_WILL_SET: "entity_builder.schema.warning.backfill.will.set";
+    readonly REFERENCES_REWRITTEN: "entity_builder.schema.warning.references.rewritten";
+    readonly STILL_REFERENCED: "entity_builder.schema.warning.still.referenced";
+    readonly FIELD_OPTIONAL_AGAIN: "entity_builder.schema.warning.field.optional.again";
+    readonly VALUES_DELETED: "entity_builder.schema.warning.values.deleted";
+    readonly COLUMN_ALREADY_MISSING: "entity_builder.schema.warning.column.already.missing";
+    readonly SOFT_DELETE_OFF: "entity_builder.schema.warning.soft.delete.off";
+    readonly AUDIT_OFF: "entity_builder.schema.warning.audit.off";
+    readonly ENTITY_REFERENCED: "entity_builder.schema.warning.entity.referenced";
+    readonly RECORDS_DELETED: "entity_builder.schema.warning.records.deleted";
+    readonly TABLE_ALREADY_MISSING: "entity_builder.schema.warning.table.already.missing";
+    readonly TABLE_RECREATED_EMPTY: "entity_builder.schema.warning.table.recreated.empty";
+    readonly UNIQUE_NOT_RECREATED: "entity_builder.schema.warning.unique.not.recreated";
+    readonly REQUIRED_HAS_NULLS: "entity_builder.schema.warning.required.has.nulls";
+    readonly NEEDS_MANUAL_ATTENTION: "entity_builder.schema.warning.needs.manual.attention";
+    readonly NOTHING_TO_REPAIR: "entity_builder.schema.warning.nothing.to.repair";
+    readonly FOLLOW_UP_FAILED: "entity_builder.schema.warning.follow.up.failed";
+    readonly ENDPOINT_FLOW_FAILED: "entity_builder.schema.warning.endpoint.flow.failed";
+    readonly MYSQL_NO_ROLLBACK: "entity_builder.schema.warning.mysql.no.rollback";
+};
+export declare const SCHEMA_STEP_MESSAGES: {
+    readonly CREATE_TABLE: "entity_builder.schema.step.create.table";
+    readonly ADD_COLUMN: "entity_builder.schema.step.add.column";
+    readonly BACKFILL_EXISTING: "entity_builder.schema.step.backfill.existing";
+    readonly BACKFILL_RECORDS: "entity_builder.schema.step.backfill.records";
+    readonly MAKE_REQUIRED: "entity_builder.schema.step.make.required";
+    readonly MAKE_OPTIONAL: "entity_builder.schema.step.make.optional";
+    readonly ADD_UNIQUE: "entity_builder.schema.step.add.unique";
+    readonly REMOVE_UNIQUE: "entity_builder.schema.step.remove.unique";
+    readonly ADD_INDEX: "entity_builder.schema.step.add.index";
+    readonly REMOVE_INDEX: "entity_builder.schema.step.remove.index";
+    readonly CONVERT_TYPE: "entity_builder.schema.step.convert.type";
+    readonly RENAME_COLUMN: "entity_builder.schema.step.rename.column";
+    readonly RENAME_INDEX: "entity_builder.schema.step.rename.index";
+    readonly RELAX_DEPRECATED: "entity_builder.schema.step.relax.deprecated";
+    readonly DROP_COLUMN: "entity_builder.schema.step.drop.column";
+    readonly DROP_TABLE: "entity_builder.schema.step.drop.table";
+    readonly ADD_DELETED_AT: "entity_builder.schema.step.add.deleted.at";
+    readonly ADD_AUDIT_COLUMNS: "entity_builder.schema.step.add.audit.columns";
+    readonly RECREATE_TABLE: "entity_builder.schema.step.recreate.table";
+    readonly ADD_SYSTEM_COLUMN: "entity_builder.schema.step.add.system.column";
+    readonly ADD_MISSING_COLUMN: "entity_builder.schema.step.add.missing.column";
+    readonly RECREATE_INDEX: "entity_builder.schema.step.recreate.index";
+    readonly RECREATE_UNIQUE: "entity_builder.schema.step.recreate.unique";
+};
+export declare const SCHEMA_FINDING_MESSAGES: {
+    readonly MISSING_TABLE: "entity_builder.schema.finding.missing.table";
+    readonly SYSTEM_COLUMN_MISSING: "entity_builder.schema.finding.system.column.missing";
+    readonly COLUMN_MISSING: "entity_builder.schema.finding.column.missing";
+    readonly TYPE_MISMATCH: "entity_builder.schema.finding.type.mismatch";
+    readonly REQUIRED_BUT_NULLABLE: "entity_builder.schema.finding.required.but.nullable";
+    readonly OPTIONAL_BUT_NOT_NULL: "entity_builder.schema.finding.optional.but.not.null";
+    readonly INDEX_MISSING: "entity_builder.schema.finding.index.missing";
+    readonly UNIQUE_MISSING: "entity_builder.schema.finding.unique.missing";
+    readonly STALE_METADATA: "entity_builder.schema.finding.stale.metadata";
+    readonly EXTRA_COLUMN: "entity_builder.schema.finding.extra.column";
+};
+export declare const SCHEMA_IMPACT_MESSAGES: {
+    readonly FLOW_ON_ENTITY: "entity_builder.schema.impact.flow.on.entity";
+    readonly FLOW_USES_FIELD: "entity_builder.schema.impact.flow.uses.field";
+};
+export declare const SCHEMA_PRECHECK_MESSAGES: {
+    readonly NOT_EMAIL: "entity_builder.schema.precheck.not.email";
+    readonly TOO_LONG: "entity_builder.schema.precheck.too.long";
+    readonly NOT_WHOLE_NUMBER: "entity_builder.schema.precheck.not.whole.number";
+    readonly NOT_NUMBER: "entity_builder.schema.precheck.not.number";
+    readonly NOT_BOOLEAN_TEXT: "entity_builder.schema.precheck.not.boolean.text";
+    readonly NOT_DATE: "entity_builder.schema.precheck.not.date";
+    readonly NOT_DATETIME: "entity_builder.schema.precheck.not.datetime";
+    readonly OUT_OF_INTEGER_RANGE: "entity_builder.schema.precheck.out.of.integer.range";
+    readonly NOT_ZERO_OR_ONE: "entity_builder.schema.precheck.not.zero.or.one";
+    readonly MULTIPLE_SELECTED: "entity_builder.schema.precheck.multiple.selected";
+};
+export declare const FIELD_VALIDATION_MESSAGES: {
+    readonly REQUIRED: "entity_builder.validation.required";
+    readonly MUST_BE_TEXT: "entity_builder.validation.must.be.text";
+    readonly MAX_LENGTH: "entity_builder.validation.max.length";
+    readonly MIN_LENGTH: "entity_builder.validation.min.length";
+    readonly INVALID_EMAIL: "entity_builder.validation.invalid.email";
+    readonly ONE_OF: "entity_builder.validation.one.of";
+    readonly WHOLE_NUMBER: "entity_builder.validation.whole.number";
+    readonly NUMBER_BETWEEN: "entity_builder.validation.number.between";
+    readonly NUMBER: "entity_builder.validation.number";
+    readonly NUMBER_TOO_LARGE: "entity_builder.validation.number.too.large";
+    readonly BOOLEAN: "entity_builder.validation.boolean";
+    readonly REAL_DATE: "entity_builder.validation.real.date";
+    readonly ISO_DATETIME: "entity_builder.validation.iso.datetime";
+    readonly TEXT_LIST: "entity_builder.validation.text.list";
+    readonly UNKNOWN_OPTIONS: "entity_builder.validation.unknown.options";
+    readonly UUID: "entity_builder.validation.uuid";
+    readonly JSON: "entity_builder.validation.json";
+    readonly MIN_VALUE: "entity_builder.validation.min.value";
+    readonly MAX_VALUE: "entity_builder.validation.max.value";
+    readonly MIN_ITEMS: "entity_builder.validation.min.items";
+    readonly MAX_ITEMS: "entity_builder.validation.max.items";
+    readonly MUST_BE_LIST: "entity_builder.validation.must.be.list";
+    readonly MUST_BE_OBJECT: "entity_builder.validation.must.be.object";
+    readonly RELATED_NOT_FOUND: "entity_builder.validation.related.not.found";
+};
+export declare const RULE_ENGINE_MESSAGES: {
+    readonly TEMPLATE_TOO_LONG: "entity_builder.rule_engine.template.too.long";
+    readonly INVALID_FIELD_REFERENCE: "entity_builder.rule_engine.invalid.field.reference";
+    readonly UNKNOWN_FUNCTION: "entity_builder.rule_engine.unknown.function";
+    readonly EXPECTED_NUMBER: "entity_builder.rule_engine.expected.number";
+    readonly DIVISION_BY_ZERO: "entity_builder.rule_engine.division.by.zero";
+    readonly MAX_DEPTH_EXCEEDED: "entity_builder.rule_engine.max.depth.exceeded";
+    readonly MAX_CONDITIONS_EXCEEDED: "entity_builder.rule_engine.max.conditions.exceeded";
+    readonly CONDITION_INCOMPLETE: "entity_builder.rule_engine.condition.incomplete";
+    readonly EXPECTED_DATE: "entity_builder.rule_engine.expected.date";
+    readonly INVALID_DURATION_UNIT: "entity_builder.rule_engine.invalid.duration.unit";
+    readonly INVALID_UTC_OFFSET: "entity_builder.rule_engine.invalid.utc.offset";
+    readonly REGEX_INVALID: "entity_builder.rule_engine.regex.invalid";
+    readonly REGEX_PATTERN_TOO_LONG: "entity_builder.rule_engine.regex.pattern.too.long";
+    readonly REGEX_INPUT_TOO_LONG: "entity_builder.rule_engine.regex.input.too.long";
+    readonly LOOKUP_RESOLVER_UNAVAILABLE: "entity_builder.rule_engine.lookup.resolver.unavailable";
+    readonly LOOKUP_LIMIT_EXCEEDED: "entity_builder.rule_engine.lookup.limit.exceeded";
+    readonly TOO_MANY_PERMISSION_CODES: "entity_builder.rule_engine.too.many.permission.codes";
+    readonly INVALID_IP_RANGE: "entity_builder.rule_engine.invalid.ip.range";
+    readonly TOO_MANY_IP_RANGES: "entity_builder.rule_engine.too.many.ip.ranges";
+    readonly UNKNOWN_COMPARISON: "entity_builder.rule_engine.unknown.comparison";
+    readonly UNKNOWN_GROUP_OPERATOR: "entity_builder.rule_engine.unknown.group.operator";
+    readonly REGEX_TOO_COMPLEX: "entity_builder.rule_engine.regex.too.complex";
+};
+export declare const FLOW_MESSAGES: {
+    readonly NOT_FOUND: "entity_builder.flow.not.found";
+    readonly NOTHING_TO_TEST: "entity_builder.flow.nothing.to.test";
+    readonly INVALID: "entity_builder.flow.invalid";
+    readonly SLUG_TAKEN: "entity_builder.flow.slug.taken";
+    readonly RATE_LIMITED: "entity_builder.flow.rate.limited";
+    readonly API_KEY_INVALID: "entity_builder.flow.api.key.invalid";
+    readonly API_KEY_NOT_FOUND: "entity_builder.flow.api.key.not.found";
+    readonly API_KEY_CREATE_SUCCESS: "entity_builder.flow.api.key.create.success";
+    readonly API_KEY_LIST_SUCCESS: "entity_builder.flow.api.key.list.success";
+    readonly API_KEY_REVOKE_SUCCESS: "entity_builder.flow.api.key.revoke.success";
+    readonly API_KEY_DELETE_SUCCESS: "entity_builder.flow.api.key.delete.success";
+    readonly API_KEY_EXPIRED: "entity_builder.flow.api.key.expired";
+    readonly API_KEY_EXPIRY_IN_PAST: "entity_builder.flow.api.key.expiry.in.past";
+    readonly CALLED_BY_OTHER_FLOWS: "entity_builder.flow.called.by.other.flows";
+    readonly EXECUTION_NOT_FOUND: "entity_builder.flow.execution.not.found";
+    readonly EXECUTIONS_SUCCESS: "entity_builder.flow.executions.success";
+    readonly EXECUTION_SUCCESS: "entity_builder.flow.execution.success";
+    readonly REJECTED: "entity_builder.flow.rejected";
+    readonly FAILED: "entity_builder.flow.failed";
+    readonly FAILED_AT_NODE: "entity_builder.flow.failed.at.node";
+    readonly FAILED_AT_NODE_DETAIL: "entity_builder.flow.failed.at.node.detail";
+    readonly FAILED_DETAIL: "entity_builder.flow.failed.detail";
+    readonly COMPLETED: "entity_builder.flow.completed";
+    readonly VALIDATE_OK: "entity_builder.flow.validate.ok";
+    readonly VALIDATE_PROBLEMS: "entity_builder.flow.validate.problems";
+    readonly TEST_SUCCESS: "entity_builder.flow.test.success";
+    readonly INPUT_INVALID: "entity_builder.flow.input.invalid";
+    readonly INPUT_BODY_NOT_LIST: "entity_builder.flow.input.body.not.list";
+    readonly INPUT_BODY_ITEM_NOT_OBJECT: "entity_builder.flow.input.body.item.not.object";
+    readonly CHECKS_FAILED: "entity_builder.flow.checks.failed";
+    readonly PERMISSION_DENIED: "entity_builder.flow.permission.denied";
+};
+export declare const FLOW_ERROR_MESSAGES: {
+    readonly NO_TRIGGER: "entity_builder.flow.error.no.trigger";
+    readonly TOO_MANY_STEPS: "entity_builder.flow.error.too.many.steps";
+    readonly OUT_OF_TIME: "entity_builder.flow.error.out.of.time";
+    readonly TOO_MANY_ITEMS: "entity_builder.flow.error.too.many.items";
+    readonly TOO_MANY_HTTP_CALLS: "entity_builder.flow.error.too.many.http.calls";
+    readonly UNKNOWN_NODE_TYPE: "entity_builder.flow.error.unknown.node.type";
+    readonly RECORD_ID_MISSING: "entity_builder.flow.error.record.id.missing";
+    readonly LIST_NOT_A_LIST: "entity_builder.flow.error.list.not.a.list";
+    readonly TOO_MANY_WRITES: "entity_builder.flow.error.too.many.writes";
+    readonly WRITE_FILTER_EMPTY: "entity_builder.flow.error.write.filter.empty";
+    readonly TOO_MANY_MATCHES: "entity_builder.flow.error.too.many.matches";
+    readonly URL_EMPTY: "entity_builder.flow.error.url.empty";
+    readonly URL_INVALID: "entity_builder.flow.error.url.invalid";
+    readonly URL_PROTOCOL: "entity_builder.flow.error.url.protocol";
+    readonly URL_CREDENTIALS: "entity_builder.flow.error.url.credentials";
+    readonly URL_PRIVATE: "entity_builder.flow.error.url.private";
+    readonly RESPONSE_TOO_LARGE: "entity_builder.flow.error.response.too.large";
+    readonly RESPONSE_INCOMPLETE: "entity_builder.flow.error.response.incomplete";
+    readonly REQUEST_TIMEOUT: "entity_builder.flow.error.request.timeout";
+    readonly NODE_FAILED: "entity_builder.flow.error.node.failed";
+    readonly CODE_THREW: "entity_builder.flow.error.code.threw";
+    readonly CODE_TIMEOUT: "entity_builder.flow.error.code.timeout";
+    readonly CODE_OUT_OF_MEMORY: "entity_builder.flow.error.code.out.of.memory";
+    readonly CODE_OUTPUT_TOO_LARGE: "entity_builder.flow.error.code.output.too.large";
+    readonly CODE_OUTPUT_INVALID: "entity_builder.flow.error.code.output.invalid";
+    readonly CODE_UNAVAILABLE: "entity_builder.flow.error.code.unavailable";
+    readonly CALLED_FLOW_NOT_FOUND: "entity_builder.flow.error.called.flow.not.found";
+    readonly CALLED_FLOW_NOT_ALLOWED: "entity_builder.flow.error.called.flow.not.allowed";
+    readonly CALLED_FLOW_RECURSION: "entity_builder.flow.error.called.flow.recursion";
+    readonly CALLED_FLOW_TOO_DEEP: "entity_builder.flow.error.called.flow.too.deep";
+    readonly CALLED_FLOW_FAILED: "entity_builder.flow.error.called.flow.failed";
+    readonly CALLED_FLOW_FAILED_AT_NODE: "entity_builder.flow.error.called.flow.failed.at.node";
+    readonly RUN_AS_NOT_ALLOWED: "entity_builder.flow.error.run.as.not.allowed";
+    readonly FILTER_VALUE_MISSING: "entity_builder.flow.error.filter.value.missing";
+};
+export declare const FLOW_SKIP_MESSAGES: {
+    readonly HTTP: "entity_builder.flow.skip.http";
+    readonly EVENTS: "entity_builder.flow.skip.events";
+    readonly COMMIT_DRY_RUN: "entity_builder.flow.skip.commit.dry.run";
+    readonly COMMIT_NO_TRANSACTION: "entity_builder.flow.skip.commit.no.transaction";
+    readonly COMMIT_JOINED: "entity_builder.flow.skip.commit.joined";
+};
+export declare const FLOW_VALIDATION_MESSAGES: {
+    readonly SLUG_INVALID: "entity_builder.flow.validation.slug.invalid";
+    readonly RUN_AS_CALLER_NEEDS_AUTH: "entity_builder.flow.validation.run.as.caller.needs.auth";
+    readonly RUN_AS_INVALID: "entity_builder.flow.validation.run.as.invalid";
+    readonly AUTH_MODE_INVALID: "entity_builder.flow.validation.auth.mode.invalid";
+    readonly NO_NODES: "entity_builder.flow.validation.no.nodes";
+    readonly TOO_MANY_NODES: "entity_builder.flow.validation.too.many.nodes";
+    readonly TOO_MANY_EDGES: "entity_builder.flow.validation.too.many.edges";
+    readonly NODE_ID_INVALID: "entity_builder.flow.validation.node.id.invalid";
+    readonly NODE_ID_DUPLICATE: "entity_builder.flow.validation.node.id.duplicate";
+    readonly NODE_TYPE_UNKNOWN: "entity_builder.flow.validation.node.type.unknown";
+    readonly TRIGGER_COUNT: "entity_builder.flow.validation.trigger.count";
+    readonly EDGE_ID_DUPLICATE: "entity_builder.flow.validation.edge.id.duplicate";
+    readonly EDGE_DANGLING: "entity_builder.flow.validation.edge.dangling";
+    readonly EDGE_SELF: "entity_builder.flow.validation.edge.self";
+    readonly EDGE_INTO_TRIGGER: "entity_builder.flow.validation.edge.into.trigger";
+    readonly EDGE_NO_PORT: "entity_builder.flow.validation.edge.no.port";
+    readonly EDGE_TWICE: "entity_builder.flow.validation.edge.twice";
+    readonly CYCLE: "entity_builder.flow.validation.cycle";
+    readonly NODE_UNREACHABLE: "entity_builder.flow.validation.node.unreachable";
+    readonly TRANSACTIONAL_HTTP: "entity_builder.flow.validation.transactional.http";
+    readonly WRITES_NOT_TRANSACTIONAL: "entity_builder.flow.validation.writes.not.transactional";
+    readonly NODE_COMMIT_CONTINUE: "entity_builder.flow.validation.node.commit.continue";
+    readonly COMMIT_NOT_TRANSACTIONAL: "entity_builder.flow.validation.commit.not.transactional";
+    readonly COMMIT_IN_LOOP: "entity_builder.flow.validation.commit.in.loop";
+    readonly COMMIT_IN_CALLED_FLOW: "entity_builder.flow.validation.commit.in.called.flow";
+    readonly PUBLIC_SYSTEM_ENTITY: "entity_builder.flow.validation.public.system.entity";
+    readonly PERMISSION_WITHOUT_USER: "entity_builder.flow.validation.permission.without.user";
+    readonly INPUT_TOO_MANY: "entity_builder.flow.validation.input.too.many";
+    readonly INPUT_NAME_INVALID: "entity_builder.flow.validation.input.name.invalid";
+    readonly INPUT_NAME_DUPLICATE: "entity_builder.flow.validation.input.name.duplicate";
+    readonly INPUT_TYPE_UNKNOWN: "entity_builder.flow.validation.input.type.unknown";
+    readonly INPUT_CHOICE_NO_OPTIONS: "entity_builder.flow.validation.input.choice.no.options";
+    readonly INPUT_ITEM_TYPE_UNKNOWN: "entity_builder.flow.validation.input.item.type.unknown";
+    readonly INPUT_TOO_DEEP: "entity_builder.flow.validation.input.too.deep";
+    readonly BODY_TYPE_UNKNOWN: "entity_builder.flow.validation.body.type.unknown";
+    readonly NODE_EXPRESSION_PROBLEM: "entity_builder.flow.validation.node.expression.problem";
+    readonly NODE_RULE_PROBLEM: "entity_builder.flow.validation.node.rule.problem";
+    readonly NODE_PAIRS_INVALID: "entity_builder.flow.validation.node.pairs.invalid";
+    readonly NODE_CHOOSE_ENTITY: "entity_builder.flow.validation.node.choose.entity";
+    readonly NODE_ENTITY_UNKNOWN: "entity_builder.flow.validation.node.entity.unknown";
+    readonly NODE_STATUS_4XX: "entity_builder.flow.validation.node.status.4xx";
+    readonly NODE_SETS_NOTHING: "entity_builder.flow.validation.node.sets.nothing";
+    readonly NODE_VARIABLE_INVALID: "entity_builder.flow.validation.node.variable.invalid";
+    readonly NODE_CASE_REQUIRED: "entity_builder.flow.validation.node.case.required";
+    readonly NODE_CASE_INVALID: "entity_builder.flow.validation.node.case.invalid";
+    readonly NODE_CASE_DUPLICATE: "entity_builder.flow.validation.node.case.duplicate";
+    readonly NODE_MAX_ITEMS_RANGE: "entity_builder.flow.validation.node.max.items.range";
+    readonly NODE_LIMIT_RANGE: "entity_builder.flow.validation.node.limit.range";
+    readonly NODE_WRITE_TARGET_INVALID: "entity_builder.flow.validation.node.write.target.invalid";
+    readonly NODE_NOT_FOUND_INVALID: "entity_builder.flow.validation.node.not.found.invalid";
+    readonly NODE_FILTER_REQUIRED: "entity_builder.flow.validation.node.filter.required";
+    readonly NODE_CHILDREN_INVALID: "entity_builder.flow.validation.node.children.invalid";
+    readonly NODE_CHILDREN_TOO_MANY: "entity_builder.flow.validation.node.children.too.many";
+    readonly NODE_CHILD_NAME_INVALID: "entity_builder.flow.validation.node.child.name.invalid";
+    readonly NODE_CHILD_NAME_DUPLICATE: "entity_builder.flow.validation.node.child.name.duplicate";
+    readonly NODE_CHILD_PARENT_FIELD_REQUIRED: "entity_builder.flow.validation.node.child.parent.field.required";
+    readonly NODE_CHOOSE_FLOW: "entity_builder.flow.validation.node.choose.flow";
+    readonly NODE_FLOW_UNKNOWN: "entity_builder.flow.validation.node.flow.unknown";
+    readonly NODE_CALLS_ITSELF: "entity_builder.flow.validation.node.calls.itself";
+    readonly NODE_FLOW_INACTIVE: "entity_builder.flow.validation.node.flow.inactive";
+    readonly NODE_FLOW_API_KEY: "entity_builder.flow.validation.node.flow.api.key";
+    readonly NODE_FLOW_INPUT_MISSING: "entity_builder.flow.validation.node.flow.input.missing";
+    readonly NODE_FLOW_INPUT_UNDECLARED: "entity_builder.flow.validation.node.flow.input.undeclared";
+    readonly NODE_FLOW_INPUT_LIST_REQUIRED: "entity_builder.flow.validation.node.flow.input.list.required";
+    readonly NODE_FLOW_INPUT_LIST_UNEXPECTED: "entity_builder.flow.validation.node.flow.input.list.unexpected";
+    readonly NODE_FLOW_LOOP: "entity_builder.flow.validation.node.flow.loop";
+    readonly NODE_FLOW_TOO_DEEP: "entity_builder.flow.validation.node.flow.too.deep";
+    readonly NODE_CHOOSE_METHOD: "entity_builder.flow.validation.node.choose.method";
+    readonly NODE_TIMEOUT_RANGE: "entity_builder.flow.validation.node.timeout.range";
+    readonly NODE_EVENT_NAME_INVALID: "entity_builder.flow.validation.node.event.name.invalid";
+    readonly NODE_STATUS_2XX_5XX: "entity_builder.flow.validation.node.status.2xx.5xx";
+    readonly REF_BAD_SCOPE: "entity_builder.flow.validation.ref.bad.scope";
+    readonly REF_NODE_MISSING: "entity_builder.flow.validation.ref.node.missing";
+    readonly REF_SELF: "entity_builder.flow.validation.ref.self";
+    readonly REF_INPUT_UNDECLARED: "entity_builder.flow.validation.ref.input.undeclared";
+    readonly REF_NODE_NOT_YET: "entity_builder.flow.validation.ref.node.not.yet";
+    readonly REF_LOOP_OUTSIDE: "entity_builder.flow.validation.ref.loop.outside";
+    readonly REF_LOOP_PARENT_MISSING: "entity_builder.flow.validation.ref.loop.parent.missing";
+    readonly REF_LOOP_RESULTS_EARLY: "entity_builder.flow.validation.ref.loop.results.early";
+    readonly LOOP_TOO_DEEP: "entity_builder.flow.validation.loop.too.deep";
+    readonly NODE_CHECK_REQUIRED: "entity_builder.flow.validation.node.check.required";
+    readonly NODE_TOO_MANY_CHECKS: "entity_builder.flow.validation.node.too.many.checks";
+    readonly NODE_CHECK_ID_INVALID: "entity_builder.flow.validation.node.check.id.invalid";
+    readonly NODE_CHECK_ID_DUPLICATE: "entity_builder.flow.validation.node.check.id.duplicate";
+    readonly NODE_CHECK_MESSAGE_REQUIRED: "entity_builder.flow.validation.node.check.message.required";
+    readonly NODE_CHECK_FIELD_INVALID: "entity_builder.flow.validation.node.check.field.invalid";
+    readonly NODE_MODE_INVALID: "entity_builder.flow.validation.node.mode.invalid";
+    readonly NODE_PERMISSION_REQUIRED: "entity_builder.flow.validation.node.permission.required";
+    readonly NODE_PERMISSION_OPTION_INVALID: "entity_builder.flow.validation.node.permission.option.invalid";
+    readonly NODE_CODE_REQUIRED: "entity_builder.flow.validation.node.code.required";
+    readonly NODE_CODE_TOO_LONG: "entity_builder.flow.validation.node.code.too.long";
+    readonly NODE_CODE_TIMEOUT_RANGE: "entity_builder.flow.validation.node.code.timeout.range";
+};
+export declare const FLOW_SHAPE_MESSAGES: {
+    readonly NOT_AN_EXPRESSION: "entity_builder.flow.shape.not.an.expression";
+    readonly TOO_DEEP: "entity_builder.flow.shape.too.deep";
+    readonly EMPTY_REFERENCE: "entity_builder.flow.shape.empty.reference";
+    readonly NO_TEMPLATE_TEXT: "entity_builder.flow.shape.no.template.text";
+    readonly TEMPLATE_TOO_LONG: "entity_builder.flow.shape.template.too.long";
+    readonly NO_OPERANDS: "entity_builder.flow.shape.no.operands";
+    readonly NO_PARTS: "entity_builder.flow.shape.no.parts";
+    readonly NO_ARGUMENTS: "entity_builder.flow.shape.no.arguments";
+    readonly UNKNOWN_EXPRESSION_TYPE: "entity_builder.flow.shape.unknown.expression.type";
+    readonly NOT_A_RULE: "entity_builder.flow.shape.not.a.rule";
+    readonly TOO_MANY_CONDITIONS: "entity_builder.flow.shape.too.many.conditions";
+    readonly UNKNOWN_OPERATOR: "entity_builder.flow.shape.unknown.operator";
+    readonly CONDITION_INCOMPLETE: "entity_builder.flow.shape.condition.incomplete";
+    readonly UNKNOWN_COMPARISON: "entity_builder.flow.shape.unknown.comparison";
+    readonly REGEX_INVALID: "entity_builder.flow.shape.regex.invalid";
+    readonly REGEX_TOO_LONG: "entity_builder.flow.shape.regex.too.long";
+    readonly REGEX_TOO_COMPLEX: "entity_builder.flow.shape.regex.too.complex";
+    readonly UNKNOWN_FUNCTION: "entity_builder.flow.shape.unknown.function";
+    readonly WRONG_ARGUMENT_COUNT: "entity_builder.flow.shape.wrong.argument.count";
+    readonly DURATION_UNIT_INVALID: "entity_builder.flow.shape.duration.unit.invalid";
+    readonly PERMISSION_CODE_REQUIRED: "entity_builder.flow.shape.permission.code.required";
+    readonly IP_RANGE_INVALID: "entity_builder.flow.shape.ip.range.invalid";
+    readonly LOOKUP_ENTITY_INVALID: "entity_builder.flow.shape.lookup.entity.invalid";
+    readonly LOOKUP_ENTITY_UNKNOWN: "entity_builder.flow.shape.lookup.entity.unknown";
+    readonly LOOKUP_MODE_INVALID: "entity_builder.flow.shape.lookup.mode.invalid";
+    readonly LOOKUP_FILTER_INVALID: "entity_builder.flow.shape.lookup.filter.invalid";
+    readonly LOOKUP_FIELD_INVALID: "entity_builder.flow.shape.lookup.field.invalid";
+    readonly FILTER_OPERATOR_UNKNOWN: "entity_builder.flow.shape.filter.operator.unknown";
+    readonly FILTER_VALUE_REQUIRED: "entity_builder.flow.shape.filter.value.required";
+};
+export declare const FLOW_SUBJECT_MESSAGES: {
+    readonly THE_RULE: "entity_builder.flow.subject.the.rule";
+    readonly THE_CHECK: "entity_builder.flow.subject.the.check";
+    readonly THE_VALUE: "entity_builder.flow.subject.the.value";
+    readonly THE_LIST: "entity_builder.flow.subject.the.list";
+    readonly CHILD_LIST: "entity_builder.flow.subject.child.list";
+    readonly CHILD_FIELD: "entity_builder.flow.subject.child.field";
+    readonly THE_COLLECTED_VALUE: "entity_builder.flow.subject.the.collected.value";
+    readonly THE_RECORD_ID: "entity_builder.flow.subject.the.record.id";
+    readonly THE_SEARCH_TEXT: "entity_builder.flow.subject.the.search.text";
+    readonly THE_URL: "entity_builder.flow.subject.the.url";
+    readonly THE_INPUT_LIST: "entity_builder.flow.subject.the.input.list";
+    readonly THE_RESPONSE: "entity_builder.flow.subject.the.response";
+    readonly VARIABLES: "entity_builder.flow.subject.variables";
+    readonly VARIABLE: "entity_builder.flow.subject.variable";
+    readonly FIELDS: "entity_builder.flow.subject.fields";
+    readonly FIELD: "entity_builder.flow.subject.field";
+    readonly FILTERS: "entity_builder.flow.subject.filters";
+    readonly FILTER: "entity_builder.flow.subject.filter";
+    readonly INPUTS: "entity_builder.flow.subject.inputs";
+    readonly INPUT: "entity_builder.flow.subject.input";
+    readonly HEADERS: "entity_builder.flow.subject.headers";
+    readonly HEADER: "entity_builder.flow.subject.header";
+    readonly BODY_VALUES: "entity_builder.flow.subject.body.values";
+    readonly BODY_VALUE: "entity_builder.flow.subject.body.value";
+    readonly PAYLOAD_VALUES: "entity_builder.flow.subject.payload.values";
+    readonly PAYLOAD_VALUE: "entity_builder.flow.subject.payload.value";
+    readonly RESPONSE_VALUES: "entity_builder.flow.subject.response.values";
+    readonly RESPONSE_VALUE: "entity_builder.flow.subject.response.value";
+};

package/controllers/entity-definition.controller.d.ts

@@ -0,0 +1,40 @@
+import { type ILoggedUserInfo, type IMessageRef, SingleResponseDto } from '@flusys/nestjs-shared';
+import { SharedPermissionCacheService } from '@flusys/nestjs-shared/modules';
+import { CreateDynamicEntityDto, EntityDefinitionResponseDto, UpdateEntityDefinitionDto } from '../dtos/entity-definition.dto.js';
+import { SchemaChangeRequestDto, SchemaCheckRequestDto } from '../dtos/schema-change.dto.js';
+import { SchemaEvolutionService } from '../services/schema-evolution.service.js';
+import { EntityDefinitionService } from '../services/entity-definition.service.js';
+import { SchemaSyncService } from '../services/schema-sync.service.js';
+declare const EntityDefinitionController_base: abstract new (service: EntityDefinitionService) => {
+    readonly enabledEndpoints: import("@flusys/nestjs-shared").ApiEndpoint[] | "all";
+    service: EntityDefinitionService;
+    isEnabled(endpoint: import("@flusys/nestjs-shared").ApiEndpoint): boolean;
+    insert(addDto: CreateDynamicEntityDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<EntityDefinitionResponseDto>>;
+    insertMany(addDto: CreateDynamicEntityDto[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").BulkResponseDto<EntityDefinitionResponseDto>>;
+    getById(id: string, body: import("@flusys/nestjs-shared").GetByIdBodyDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<EntityDefinitionResponseDto>>;
+    getByIds(body: import("@flusys/nestjs-shared").GetByIdsDto, user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").ListResponseDto<EntityDefinitionResponseDto>>;
+    update(updateDto: UpdateEntityDefinitionDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<EntityDefinitionResponseDto>>;
+    updateMany(updateDtos: UpdateEntityDefinitionDto[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").BulkResponseDto<EntityDefinitionResponseDto>>;
+    bulkUpsert(dtos: (UpdateEntityDefinitionDto | CreateDynamicEntityDto)[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").BulkResponseDto<EntityDefinitionResponseDto>>;
+    getByFilter(filter: Record<string, any>, user: ILoggedUserInfo | null): Promise<SingleResponseDto<EntityDefinitionResponseDto>>;
+    getAll(filterAndPaginationDto: import("@flusys/nestjs-shared").FilterAndPaginationDto, user: ILoggedUserInfo | null, search?: string): Promise<import("@flusys/nestjs-shared").ListResponseDto<EntityDefinitionResponseDto>>;
+    delete(deleteDto: import("@flusys/nestjs-shared").DeleteDto, user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").MessageResponseDto>;
+};
+export declare class EntityDefinitionController extends EntityDefinitionController_base {
+    entityDefinitionService: EntityDefinitionService;
+    private readonly schemaSyncService;
+    private readonly evolution;
+    private readonly permissionCache;
+    constructor(entityDefinitionService: EntityDefinitionService, schemaSyncService: SchemaSyncService, evolution: SchemaEvolutionService, permissionCache: SharedPermissionCacheService);
+    createEntity(dto: CreateDynamicEntityDto, user: ILoggedUserInfo): Promise<SingleResponseDto<EntityDefinitionResponseDto> & {
+        warnings: IMessageRef[];
+    }>;
+    planCreateEntity(dto: CreateDynamicEntityDto, user: ILoggedUserInfo): Promise<SingleResponseDto<import("../index.js").ISchemaChangePlan>>;
+    planChange(dto: SchemaChangeRequestDto, user: ILoggedUserInfo): Promise<SingleResponseDto<import("../index.js").ISchemaChangePlan>>;
+    applyChange(dto: SchemaChangeRequestDto, user: ILoggedUserInfo): Promise<SingleResponseDto<import("../index.js").ISchemaChangeApplied>>;
+    applyDestructiveChange(dto: SchemaChangeRequestDto, user: ILoggedUserInfo): Promise<SingleResponseDto<import("../index.js").ISchemaChangeApplied>>;
+    inspect(dto: SchemaCheckRequestDto): Promise<SingleResponseDto<import("../index.js").ISchemaCheckResult>>;
+    history(dto: SchemaCheckRequestDto): Promise<SingleResponseDto<import("../index.js").SchemaChangeLog[]>>;
+    private ok;
+}
+export {};

package/controllers/field-definition.controller.d.ts

@@ -0,0 +1,22 @@
+import { CreateFieldDefinitionDto, FieldDefinitionResponseDto, UpdateFieldDefinitionDto } from '../dtos/field-definition.dto.js';
+import { FieldDefinitionService } from '../services/field-definition.service.js';
+declare const FieldDefinitionController_base: abstract new (service: FieldDefinitionService) => {
+    readonly enabledEndpoints: import("@flusys/nestjs-shared").ApiEndpoint[] | "all";
+    service: FieldDefinitionService;
+    isEnabled(endpoint: import("@flusys/nestjs-shared").ApiEndpoint): boolean;
+    insert(addDto: CreateFieldDefinitionDto, user: import("@flusys/nestjs-shared").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").SingleResponseDto<FieldDefinitionResponseDto>>;
+    insertMany(addDto: CreateFieldDefinitionDto[], user: import("@flusys/nestjs-shared").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").BulkResponseDto<FieldDefinitionResponseDto>>;
+    getById(id: string, body: import("@flusys/nestjs-shared").GetByIdBodyDto, user: import("@flusys/nestjs-shared").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").SingleResponseDto<FieldDefinitionResponseDto>>;
+    getByIds(body: import("@flusys/nestjs-shared").GetByIdsDto, user: import("@flusys/nestjs-shared").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").ListResponseDto<FieldDefinitionResponseDto>>;
+    update(updateDto: UpdateFieldDefinitionDto, user: import("@flusys/nestjs-shared").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").SingleResponseDto<FieldDefinitionResponseDto>>;
+    updateMany(updateDtos: UpdateFieldDefinitionDto[], user: import("@flusys/nestjs-shared").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").BulkResponseDto<FieldDefinitionResponseDto>>;
+    bulkUpsert(dtos: (CreateFieldDefinitionDto | UpdateFieldDefinitionDto)[], user: import("@flusys/nestjs-shared").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").BulkResponseDto<FieldDefinitionResponseDto>>;
+    getByFilter(filter: Record<string, any>, user: import("@flusys/nestjs-shared").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").SingleResponseDto<FieldDefinitionResponseDto>>;
+    getAll(filterAndPaginationDto: import("@flusys/nestjs-shared").FilterAndPaginationDto, user: import("@flusys/nestjs-shared").ILoggedUserInfo | null, search?: string): Promise<import("@flusys/nestjs-shared").ListResponseDto<FieldDefinitionResponseDto>>;
+    delete(deleteDto: import("@flusys/nestjs-shared").DeleteDto, user: import("@flusys/nestjs-shared").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").MessageResponseDto>;
+};
+export declare class FieldDefinitionController extends FieldDefinitionController_base {
+    fieldDefinitionService: FieldDefinitionService;
+    constructor(fieldDefinitionService: FieldDefinitionService);
+}
+export {};

package/controllers/flow-api-key.controller.d.ts

@@ -0,0 +1,14 @@
+import { type ILoggedUserInfo, SingleResponseDto } from '@flusys/nestjs-shared';
+import { CreateFlowApiKeyDto, FlowIdDto, IdBodyDto } from '../dtos/flow.dto.js';
+import { FlowApiKeyService, type IFlowApiKeyInfo } from '../services/flow-api-key.service.js';
+export declare class FlowApiKeyController {
+    private readonly keys;
+    constructor(keys: FlowApiKeyService);
+    create(dto: CreateFlowApiKeyDto, user: ILoggedUserInfo): Promise<SingleResponseDto<{
+        key: string;
+        info: IFlowApiKeyInfo;
+    }>>;
+    list(dto: FlowIdDto): Promise<SingleResponseDto<IFlowApiKeyInfo[]>>;
+    revoke(dto: IdBodyDto): Promise<SingleResponseDto<null>>;
+    remove(dto: IdBodyDto): Promise<SingleResponseDto<null>>;
+}

package/controllers/flow-definition.controller.d.ts

@@ -0,0 +1,45 @@
+import { type ILoggedUserInfo, SingleResponseDto } from '@flusys/nestjs-shared';
+import { CreateFlowDefinitionDto, FlowDefinitionResponseDto, TestFlowDto, UpdateFlowDefinitionDto, ValidateFlowDto } from '../dtos/flow.dto.js';
+import { type IFlowValidationResult } from '../flow-engine/flow-graph.validator.js';
+import { FlowDefinitionService } from '../services/flow-definition.service.js';
+import { FlowRuntimeService } from '../services/flow-runtime.service.js';
+declare const FlowDefinitionController_base: abstract new (service: FlowDefinitionService) => {
+    readonly enabledEndpoints: import("@flusys/nestjs-shared").ApiEndpoint[] | "all";
+    service: FlowDefinitionService;
+    isEnabled(endpoint: import("@flusys/nestjs-shared").ApiEndpoint): boolean;
+    insert(addDto: CreateFlowDefinitionDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<FlowDefinitionResponseDto>>;
+    insertMany(addDto: CreateFlowDefinitionDto[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").BulkResponseDto<FlowDefinitionResponseDto>>;
+    getById(id: string, body: import("@flusys/nestjs-shared").GetByIdBodyDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<FlowDefinitionResponseDto>>;
+    getByIds(body: import("@flusys/nestjs-shared").GetByIdsDto, user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").ListResponseDto<FlowDefinitionResponseDto>>;
+    update(updateDto: UpdateFlowDefinitionDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<FlowDefinitionResponseDto>>;
+    updateMany(updateDtos: UpdateFlowDefinitionDto[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").BulkResponseDto<FlowDefinitionResponseDto>>;
+    bulkUpsert(dtos: (CreateFlowDefinitionDto | UpdateFlowDefinitionDto)[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").BulkResponseDto<FlowDefinitionResponseDto>>;
+    getByFilter(filter: Record<string, any>, user: ILoggedUserInfo | null): Promise<SingleResponseDto<FlowDefinitionResponseDto>>;
+    getAll(filterAndPaginationDto: import("@flusys/nestjs-shared").FilterAndPaginationDto, user: ILoggedUserInfo | null, search?: string): Promise<import("@flusys/nestjs-shared").ListResponseDto<FlowDefinitionResponseDto>>;
+    delete(deleteDto: import("@flusys/nestjs-shared").DeleteDto, user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").MessageResponseDto>;
+};
+export declare class FlowDefinitionController extends FlowDefinitionController_base {
+    flowDefinitionService: FlowDefinitionService;
+    private readonly runtime;
+    constructor(flowDefinitionService: FlowDefinitionService, runtime: FlowRuntimeService);
+    validate(dto: ValidateFlowDto): Promise<SingleResponseDto<IFlowValidationResult>>;
+    testRun(dto: TestFlowDto, user: ILoggedUserInfo, req: {
+        ip?: string;
+        headers: Record<string, unknown>;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        messageKey: "entity_builder.flow.test.success";
+        data: {
+            warnings: import("@flusys/nestjs-shared").IMessageRef[];
+            status: "success" | "failed" | "rejected";
+            statusCode: number;
+            body: unknown;
+            error?: string;
+            trace: import("../index.js").IFlowTraceEntry[];
+            durationMs: number;
+            savedUpTo?: import("../index.js").IFlowSavePoint;
+        };
+    }>;
+}
+export {};