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

package/fesm/21.js

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