@epilot/sdk 2.1.0 → 2.1.2

package/dist/entity-mapping-UOGYYCZH.js

@@ -0,0 +1,1506 @@
+import "./chunk-YPSWSI3M.js";
+
+// src/definitions/entity-mapping.json
+var openapi = "3.0.3";
+var info = {
+  title: "Entity Mapping API",
+  description: "API Backend for mapping source entity into target entities",
+  version: "1.0.0"
+};
+var tags = [
+  {
+    name: "mappings",
+    description: "Entity Mapping Configs"
+  }
+];
+var security = [
+  {
+    EpilotAuth: []
+  }
+];
+var paths = {
+  "/v1/mappings": {
+    post: {
+      operationId: "storeConfig",
+      summary: "storeConfig",
+      description: "Store new MappingConfig",
+      tags: ["mappings"],
+      parameters: [
+        {
+          name: "with_id",
+          in: "query",
+          required: false,
+          description: "Whether ids are part of the body or not",
+          schema: {
+            type: "string"
+          }
+        }
+      ],
+      requestBody: {
+        description: "Mapping Config to store",
+        content: {
+          "application/json": {
+            schema: {
+              $ref: "#/components/schemas/MappingConfig"
+            }
+          }
+        }
+      },
+      responses: {
+        "201": {
+          description: "The updated entity mapping config",
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/MappingConfig"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "/v1/mappings/{id}": {
+    get: {
+      operationId: "getConfig",
+      summary: "getConfig",
+      description: "Get latest version of a mapping config by id",
+      tags: ["mappings"],
+      parameters: [
+        {
+          name: "id",
+          in: "path",
+          required: true,
+          description: "Mapping Config Id",
+          schema: {
+            type: "string",
+            example: "70542580-2b38-4bfc-af8d-bb90102f9f47"
+          }
+        }
+      ],
+      responses: {
+        "200": {
+          description: "Entity Mapping Config",
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/MappingConfig"
+              }
+            }
+          }
+        }
+      }
+    },
+    delete: {
+      operationId: "deleteConfig",
+      summary: "deleteConfig",
+      description: "Delete entity mapping config",
+      tags: ["mappings"],
+      parameters: [
+        {
+          name: "id",
+          in: "path",
+          required: true,
+          description: "Mapping Config Id",
+          schema: {
+            type: "string",
+            example: "70542580-2b38-4bfc-af8d-bb90102f9f47"
+          }
+        }
+      ],
+      responses: {
+        "200": {
+          description: "The deleted mapping config",
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/MappingConfig"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "/v1/mappings/{id}/versions": {
+    get: {
+      operationId: "getAllVersions",
+      summary: "getAllVersions",
+      description: "Get all version of MappingConfig",
+      tags: ["mappings"],
+      parameters: [
+        {
+          name: "id",
+          in: "path",
+          required: true,
+          description: "Mapping Config Id",
+          schema: {
+            type: "string",
+            example: "70542580-2b38-4bfc-af8d-bb90102f9f47"
+          }
+        }
+      ],
+      responses: {
+        "200": {
+          description: "All versions of a MappingConfig",
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/MappingConfigsResp"
+              }
+            }
+          }
+        }
+      }
+    },
+    post: {
+      operationId: "storeNewVersion",
+      summary: "storeNewVersion",
+      description: "Store new version of MappingConfig",
+      tags: ["mappings"],
+      parameters: [
+        {
+          name: "id",
+          in: "path",
+          required: true,
+          description: "Mapping Config Id",
+          schema: {
+            type: "string",
+            example: "70542580-2b38-4bfc-af8d-bb90102f9f47"
+          }
+        }
+      ],
+      requestBody: {
+        description: "Mapping Config to store",
+        content: {
+          "application/json": {
+            schema: {
+              $ref: "#/components/schemas/MappingConfig"
+            }
+          }
+        }
+      },
+      responses: {
+        "200": {
+          description: "The updated entity mapping config",
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/MappingConfig"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "/v1/mappings/{id}/versions/{version}": {
+    get: {
+      operationId: "getConfigVersion",
+      summary: "getConfigVersion",
+      description: "Get specific version of a mapping config by id & version",
+      tags: ["mappings"],
+      parameters: [
+        {
+          name: "id",
+          in: "path",
+          required: true,
+          description: "Mapping Config Id",
+          schema: {
+            type: "string",
+            example: "70542580-2b38-4bfc-af8d-bb90102f9f47"
+          }
+        },
+        {
+          name: "version",
+          in: "path",
+          required: true,
+          description: "Version to be loaded",
+          schema: {
+            type: "number",
+            example: 3
+          }
+        }
+      ],
+      responses: {
+        "200": {
+          description: "Entity Mapping Config",
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/MappingConfig"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "/v1/mappings:execute": {
+    post: {
+      operationId: "executeMapping",
+      summary: "executeMapping",
+      description: "Execute entity mapping based on a config",
+      parameters: [
+        {
+          name: "preview_mode",
+          in: "query",
+          required: false,
+          description: "True, if you want to preview the entities which will result",
+          schema: {
+            type: "boolean",
+            example: true
+          }
+        }
+      ],
+      requestBody: {
+        content: {
+          "application/json": {
+            schema: {
+              $ref: "#/components/schemas/ExecuteMappingReq"
+            }
+          }
+        }
+      },
+      tags: ["mappings"],
+      responses: {
+        "200": {
+          description: "The target entities which were mapped",
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/ExecuteMappingResp"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "/v1/mappings:search": {
+    post: {
+      operationId: "searchConfigs",
+      summary: "searchConfigs",
+      description: "Search mapping configs",
+      tags: ["mappings"],
+      requestBody: {
+        description: "Search Mapping Configs",
+        content: {
+          "application/json": {
+            schema: {
+              $ref: "#/components/schemas/SearchMappingReq"
+            }
+          }
+        }
+      },
+      responses: {
+        "200": {
+          description: "Entity Mapping Config",
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/MappingConfig"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "/v1/mappings/history": {
+    get: {
+      operationId: "queryMappingHistory",
+      summary: "queryMappingHistory",
+      description: "Get the Mapping History",
+      tags: ["mappings"],
+      parameters: [
+        {
+          in: "query",
+          name: "from",
+          schema: {
+            type: "string",
+            format: "datetime"
+          },
+          required: false,
+          description: "filter the history from this date on"
+        },
+        {
+          in: "query",
+          name: "to",
+          schema: {
+            type: "string",
+            format: "datetime"
+          },
+          required: false,
+          description: "filter the history to this date on"
+        },
+        {
+          in: "query",
+          name: "targetEntityId",
+          schema: {
+            type: "string",
+            format: "uuid"
+          }
+        },
+        {
+          in: "query",
+          name: "sourceEntityId",
+          schema: {
+            type: "string",
+            format: "uuid"
+          }
+        }
+      ],
+      responses: {
+        "200": {
+          description: "Query result of mapping history",
+          content: {
+            "application/json": {
+              schema: {
+                properties: {
+                  results: {
+                    type: "array",
+                    items: {
+                      $ref: "#/components/schemas/MappingHistoryResp"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "/v1/relations:execute": {
+    post: {
+      operationId: "executeRelations",
+      summary: "executeRelations",
+      description: "Execute relation mapping between source entity and target entities",
+      requestBody: {
+        content: {
+          "application/json": {
+            schema: {
+              $ref: "#/components/schemas/ExecuteRelationsReq"
+            }
+          }
+        }
+      },
+      tags: ["mappings"],
+      responses: {
+        "200": {
+          description: "The relations which were for both source entity and main entity",
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/ExecuteRelationsResp"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "/v2/mappings/{id}": {
+    get: {
+      operationId: "getMappingConfig",
+      summary: "getMappingConfig",
+      description: "Get latest version of a mapping config by id V2",
+      tags: ["mappings"],
+      parameters: [
+        {
+          name: "id",
+          in: "path",
+          required: true,
+          description: "Mapping Config Id",
+          schema: {
+            type: "string",
+            example: "70542580-2b38-4bfc-af8d-bb90102f9f47"
+          }
+        }
+      ],
+      responses: {
+        "200": {
+          description: "Entity Mapping Config",
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/MappingConfigV2"
+              }
+            }
+          }
+        }
+      }
+    },
+    put: {
+      operationId: "putMappingConfig",
+      summary: "putMappingConfig",
+      description: "Stores new version of entity mapping config",
+      tags: ["mappings"],
+      parameters: [
+        {
+          name: "id",
+          in: "path",
+          required: true,
+          description: "Mapping Config Id",
+          schema: {
+            type: "string",
+            example: "70542580-2b38-4bfc-af8d-bb90102f9f47"
+          }
+        }
+      ],
+      requestBody: {
+        description: "Mapping Config to store",
+        content: {
+          "application/json": {
+            schema: {
+              $ref: "#/components/schemas/MappingConfigV2"
+            }
+          }
+        }
+      },
+      responses: {
+        "200": {
+          description: "The updated entity mapping config",
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/MappingConfigV2"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+var components = {
+  securitySchemes: {
+    EpilotAuth: {
+      type: "http",
+      scheme: "bearer",
+      description: "Epilot Bearer Token"
+    }
+  },
+  schemas: {
+    SearchMappingReq: {
+      type: "object",
+      properties: {
+        source: {
+          $ref: "#/components/schemas/SourceConfig"
+        }
+      }
+    },
+    MappingConfigsResp: {
+      type: "object",
+      properties: {
+        configs: {
+          $ref: "#/components/schemas/MappingConfigs"
+        }
+      },
+      required: ["configs"]
+    },
+    MappingConfigs: {
+      type: "array",
+      items: {
+        $ref: "#/components/schemas/MappingConfig"
+      }
+    },
+    MappingConfig: {
+      allOf: [
+        {
+          $ref: "#/components/schemas/MappingConfigCommonFields"
+        },
+        {
+          type: "object",
+          properties: {
+            org_id: {
+              type: "string",
+              example: "66"
+            },
+            version: {
+              type: "integer",
+              example: 2
+            }
+          }
+        }
+      ],
+      required: ["org_id", "version"]
+    },
+    MappingConfigV2: {
+      allOf: [
+        {
+          $ref: "#/components/schemas/MappingConfigCommonFields"
+        },
+        {
+          type: "object",
+          properties: {
+            org_id: {
+              type: "string",
+              example: "66",
+              readOnly: true
+            },
+            version: {
+              type: "integer",
+              example: 2,
+              readOnly: true
+            }
+          }
+        }
+      ]
+    },
+    MappingConfigCommonFields: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string"
+        },
+        source: {
+          $ref: "#/components/schemas/SourceConfig"
+        },
+        targets: {
+          type: "array",
+          items: {
+            $ref: "#/components/schemas/TargetConfig"
+          }
+        },
+        created_at: {
+          type: "string",
+          format: "date-time"
+        },
+        updated_at: {
+          type: "string",
+          format: "date-time"
+        },
+        created_by: {
+          $ref: "#/components/schemas/Owner",
+          description: "User / service who created the entity mapping config",
+          example: {
+            type: "internal_service"
+          }
+        },
+        last_updated_by: {
+          $ref: "#/components/schemas/Owner",
+          description: "User / service who last updated entity mapping config",
+          example: {
+            type: "user",
+            org_id: 255151,
+            user_id: 99252
+          }
+        }
+      },
+      required: ["id", "source", "targets"]
+    },
+    Owner: {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["user", "internal_service"]
+        },
+        org_id: {
+          type: "string"
+        },
+        user_id: {
+          type: "string"
+        }
+      },
+      required: ["type"]
+    },
+    ExecuteRelationsReq: {
+      type: "object",
+      description: "Build relations between a source entity and one or more target entities, dynamically identified",
+      properties: {
+        source_ref: {
+          $ref: "#/components/schemas/EntityRef",
+          description: "Entity for which to add relations."
+        },
+        target: {
+          type: "object",
+          properties: {
+            main_entity_ref: {
+              $ref: "#/components/schemas/EntityRef",
+              description: "Main Entity from where to locate target entities. Eg. submisssion entity"
+            },
+            relation_attributes: {
+              type: "array",
+              description: "Relation mappings",
+              items: {
+                $ref: "#/components/schemas/RelationAttribute"
+              }
+            },
+            linkback: {
+              type: "object",
+              description: "For cases where you want to store a relation between main entity (eg. submission) and current source entity.",
+              properties: {
+                attribute: {
+                  type: "string",
+                  default: "mapped_entities",
+                  description: "Relation attribute on the main entity (submission) where the target entity will be linked. Set to false to disable linkback\n"
+                },
+                relation_tags: {
+                  type: "array",
+                  description: "Relation tags (labels) to include in main entity linkback relation attribute",
+                  items: {
+                    type: "string"
+                  }
+                }
+              },
+              required: ["attribute", "relation_tags"]
+            }
+          },
+          required: ["main_entity_ref", "relation_attributes"]
+        },
+        additional_relations: {
+          type: "array",
+          items: {
+            $ref: "#/components/schemas/RelationItem"
+          }
+        }
+      },
+      required: ["source_ref"]
+    },
+    ExecuteRelationsResp: {
+      type: "object",
+      properties: {
+        relations: {
+          type: "array",
+          items: {
+            $ref: "#/components/schemas/NewRelationItem"
+          }
+        }
+      }
+    },
+    NewRelationItem: {
+      type: "object",
+      properties: {
+        source_entity_id: {
+          type: "string"
+        },
+        target_entity_id: {
+          type: "string"
+        },
+        relation_attr: {
+          type: "string"
+        },
+        tags: {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        }
+      },
+      required: ["source_entity_id", "target_entity_id", "relation_attr"]
+    },
+    RelationItem: {
+      type: "object",
+      properties: {
+        entity_id: {
+          type: "string"
+        },
+        attribute: {
+          type: "string"
+        }
+      },
+      required: ["entity_id", "attribute"]
+    },
+    ExecuteMappingReq: {
+      type: "object",
+      description: "Pass either source or source_entity",
+      properties: {
+        source_ref: {
+          $ref: "#/components/schemas/EntityRef",
+          description: "A reference (id and schema) to the entity to be used as source."
+        },
+        targets: {
+          type: "array",
+          items: {
+            $ref: "#/components/schemas/TargetConfig"
+          },
+          description: "Mapping Configuration to apply."
+        }
+      },
+      required: ["source_ref", "targets"]
+    },
+    ExecuteMappingResp: {
+      type: "object",
+      properties: {
+        mapped_entities: {
+          type: "array",
+          items: {
+            $ref: "#/components/schemas/Entity"
+          }
+        },
+        failures: {
+          type: "array",
+          items: {
+            $ref: "#/components/schemas/MappingFailure"
+          }
+        },
+        warnings: {
+          type: "array",
+          items: {
+            $ref: "#/components/schemas/MappingWarning"
+          }
+        }
+      },
+      required: ["mapped_entities"]
+    },
+    MappingFailure: {
+      type: "object",
+      properties: {
+        target: {
+          $ref: "#/components/schemas/TargetConfig"
+        },
+        error: {
+          type: "object",
+          properties: {
+            isSilent: {
+              type: "boolean"
+            },
+            message: {
+              type: "string"
+            }
+          },
+          additionalProperties: true
+        }
+      }
+    },
+    MappingWarning: {
+      type: "object",
+      properties: {
+        explanation: {
+          type: "string"
+        },
+        context: {
+          type: "string"
+        },
+        id: {
+          type: "string"
+        }
+      },
+      required: ["explanation"]
+    },
+    Entity: {
+      type: "object",
+      properties: {
+        _id: {
+          type: "string"
+        },
+        _schema: {
+          type: "string"
+        },
+        _title: {
+          type: "string",
+          nullable: true
+        },
+        _org: {
+          type: "string"
+        },
+        _tags: {
+          type: "array",
+          items: {
+            type: "string"
+          },
+          nullable: true
+        },
+        _created_at: {
+          type: "string",
+          nullable: true
+        },
+        _updated_at: {
+          type: "string",
+          nullable: true
+        },
+        required: ["_id", "_schema", "_org", "_created_at", "_updated_at"]
+      },
+      additionalProperties: true
+    },
+    EntityRef: {
+      type: "object",
+      properties: {
+        entity_id: {
+          type: "string",
+          description: "id of the source entity to be mapped"
+        },
+        entity_schema: {
+          description: "schema of the source entity",
+          type: "string",
+          example: "submission"
+        }
+      },
+      required: ["entity_id"]
+    },
+    SourceConfig: {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["journey", "entity"]
+        },
+        config: {
+          anyOf: [
+            {
+              $ref: "#/components/schemas/JourneyRef"
+            },
+            {
+              $ref: "#/components/schemas/EntityRef"
+            }
+          ]
+        }
+      }
+    },
+    JourneyRef: {
+      type: "object",
+      properties: {
+        journey_id: {
+          type: "string"
+        }
+      }
+    },
+    Loop_Index_String: {
+      type: "string",
+      description: "This string value will be replaced with the value of the loop index, when mapping in loop mode",
+      enum: ["##LOOP_INDEX##"]
+    },
+    TargetConfig: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "Identifier for target configuration. Useful for later usages when trying to identify which target config to map to."
+        },
+        name: {
+          type: "string",
+          description: "A name for this configuration"
+        },
+        allow_failure: {
+          type: "boolean",
+          description: "Pass it as true, when you don't want failures to interrupt the mapping process."
+        },
+        target_schema: {
+          type: "string",
+          description: "Schema of target entity"
+        },
+        target_unique: {
+          type: "array",
+          description: "Unique key for target entity (see upsertEntity of Entity API)",
+          items: {
+            type: "string"
+          }
+        },
+        loop_config: {
+          type: "object",
+          description: "contains config in case of running in loop mode",
+          properties: {
+            source_path: {
+              type: "string",
+              description: "path to the array from the entity payload"
+            },
+            length: {
+              type: "number",
+              description: "a hard limit of how many times the loop is allowed to run.",
+              default: "the length of the array"
+            }
+          }
+        },
+        conditionMode: {
+          description: "Mode of how conditions are considered valid",
+          type: "string",
+          enum: ["oneOf", "anyOf", "allOf"]
+        },
+        conditions: {
+          type: "array",
+          description: "Conditions necessary to hold for the target entity to be mapped",
+          items: {
+            $ref: "#/components/schemas/MapCondition"
+          }
+        },
+        mapping_attributes: {
+          type: "array",
+          description: "Attribute mappings",
+          items: {
+            anyOf: [
+              {
+                $ref: "#/components/schemas/MappingAttributeV2"
+              },
+              {
+                $ref: "#/components/schemas/MappingAttribute"
+              }
+            ]
+          }
+        },
+        relation_attributes: {
+          type: "array",
+          description: "Relation mappings",
+          items: {
+            $ref: "#/components/schemas/RelationAttribute"
+          }
+        },
+        linkback_relation_attribute: {
+          type: "string",
+          default: "mapped_entities",
+          description: "Relation attribute on the main entity where the target entity will be linked. Set to false to disable linkback\n"
+        },
+        linkback_relation_tags: {
+          type: "array",
+          description: "Relation tags (labels) to include in main entity linkback relation attribute",
+          items: {
+            type: "string"
+          }
+        }
+      },
+      required: ["target_schema", "mapping_attributes"]
+    },
+    MapCondition: {
+      type: "object",
+      properties: {
+        _exists: {
+          $ref: "#/components/schemas/ConditionNode"
+        },
+        _equals: {
+          $ref: "#/components/schemas/ConditionNode"
+        },
+        _not_exists: {
+          $ref: "#/components/schemas/ConditionNode"
+        },
+        _any_of: {
+          $ref: "#/components/schemas/ConditionNode"
+        }
+      }
+    },
+    ConditionNode: {
+      type: "object",
+      properties: {
+        source: {
+          type: "string"
+        },
+        value: {
+          oneOf: [
+            {
+              type: "string"
+            },
+            {
+              type: "number"
+            },
+            {
+              type: "object"
+            },
+            {
+              type: "array",
+              items: {
+                type: "object"
+              }
+            }
+          ]
+        }
+      }
+    },
+    RelationAttribute: {
+      type: "object",
+      properties: {
+        target: {
+          type: "string",
+          description: "Target attribute to store the relation in"
+        },
+        target_tags: {
+          type: "array",
+          description: "Relation tags (labels) to set for the stored relations",
+          items: {
+            type: "string"
+          }
+        },
+        target_tags_include_source: {
+          type: "boolean",
+          description: "Include all relation tags (labels) present on the main entity relation",
+          default: false
+        },
+        override_with_source_filter: {
+          type: "boolean",
+          description: "Whether to override the relation source_filter with the specified one",
+          default: false
+        },
+        source_filter: {
+          type: "object",
+          description: "A filter to identify which source entities to pick as relations from main entity",
+          properties: {
+            limit: {
+              type: "integer",
+              description: "Limit relations to maximum number (default, all matched relations)",
+              minimum: 0
+            },
+            schema: {
+              type: "string",
+              description: "Filter by specific schema"
+            },
+            attribute: {
+              type: "string",
+              description: "Filter by a specific relation attribute on the main entity"
+            },
+            relation_tag: {
+              type: "string",
+              description: "Filter by relation tag (label) on the main entity"
+            },
+            tag: {
+              type: "string",
+              description: "Filter by a specific tag on the related entity"
+            },
+            self: {
+              type: "boolean",
+              description: "Picks main entity as relation (overrides other filters)",
+              default: false
+            }
+          }
+        },
+        related_to: {
+          type: "object",
+          additionalProperties: true,
+          deprecated: true
+        },
+        mode: {
+          type: "string",
+          enum: ["append", "prepend", "set"]
+        },
+        origin: {
+          $ref: "#/components/schemas/AttributeOrigin"
+        }
+      },
+      required: ["target", "mode"]
+    },
+    MappingAttributeV2: {
+      type: "object",
+      properties: {
+        target: {
+          type: "string",
+          description: "Target JSON path for the attribute to set"
+        },
+        operation: {
+          $ref: "#/components/schemas/OperationNode"
+        },
+        origin: {
+          $ref: "#/components/schemas/AttributeOrigin"
+        }
+      },
+      required: ["target", "operation"],
+      example: {
+        target: "_tags",
+        operation: {
+          _append: ["new", "tags"],
+          _uniq: true
+        }
+      }
+    },
+    AttributeOrigin: {
+      type: "string",
+      description: "Origin of an attribute.",
+      enum: ["system_recommendation", "user_manually", "entity_updating_system_recommendation"]
+    },
+    OperationNode: {
+      description: "Mapping operation nodes are either primitive values or operation node objects",
+      oneOf: [
+        {
+          $ref: "#/components/schemas/OperationObjectNode"
+        },
+        {
+          $ref: "#/components/schemas/PrimitiveJSONValue"
+        }
+      ]
+    },
+    OperationObjectNode: {
+      type: "object",
+      properties: {
+        _set: {
+          $ref: "#/components/schemas/PrimitiveJSONValue"
+        },
+        _append: {
+          description: "Append to array",
+          items: {
+            $ref: "#/components/schemas/PrimitiveJSONValue"
+          }
+        },
+        _prepend: {
+          description: "Prepend to an array",
+          items: {
+            $ref: "#/components/schemas/OperationNode"
+          }
+        },
+        _uniq: {
+          description: "Unique array",
+          oneOf: [
+            {
+              type: "boolean",
+              example: true
+            },
+            {
+              type: "array",
+              description: "Unique key consisting of object keys",
+              example: ["email"],
+              items: {
+                type: "string"
+              }
+            }
+          ]
+        },
+        _retain_old_values: {
+          description: "Merge strategy when _uniq is defined",
+          type: "boolean",
+          example: true
+        },
+        _copy: {
+          description: "Copy JSONPath value from source entity context",
+          type: "string",
+          example: "contact.first_name"
+        },
+        _template: {
+          description: "Define handlebars template to output a string",
+          type: "string",
+          example: "{{contact.first_name}} {{contact.last_name}}"
+        },
+        _random: {
+          description: "Generate random ids / numbers",
+          $ref: "#/components/schemas/RandomOperation"
+        }
+      },
+      additionalProperties: true
+    },
+    PrimitiveJSONValue: {
+      description: "Represents any primitive JSON value",
+      anyOf: [
+        {
+          type: "string"
+        },
+        {
+          type: "boolean"
+        },
+        {
+          type: "number"
+        },
+        {
+          type: "object",
+          additionalProperties: true
+        },
+        {
+          type: "array"
+        }
+      ]
+    },
+    RandomOperation: {
+      oneOf: [
+        {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              enum: ["uuid", "nanoid"]
+            }
+          },
+          required: ["type"]
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              enum: ["number"]
+            },
+            min: {
+              type: "number",
+              default: 0
+            },
+            max: {
+              type: "number",
+              default: 1
+            }
+          },
+          required: ["type"]
+        }
+      ]
+    },
+    MappingAttribute: {
+      anyOf: [
+        {
+          $ref: "#/components/schemas/SetValueMapper"
+        },
+        {
+          $ref: "#/components/schemas/CopyValueMapper"
+        },
+        {
+          $ref: "#/components/schemas/AppendValueMapper"
+        }
+      ]
+    },
+    MappingAttributeMode: {
+      type: "string",
+      enum: ["copy_if_exists", "append_if_exists", "set_value"],
+      description: "- copy_if_exists - it replaces the target attribute with the source value - append_if_exists - it currently replaces target attribute with array like values. Useful when you have multiple values to be added into one attribute. - set_value - it sets a value to a predefined value. Must be used together with value property.\n"
+    },
+    SetValueMapper: {
+      type: "object",
+      deprecated: true,
+      properties: {
+        mode: {
+          $ref: "#/components/schemas/MappingAttributeMode"
+        },
+        target: {
+          type: "string",
+          description: "JSON like target path for the attribute. Eg. last_name"
+        },
+        value: {
+          description: "Any value to be set: string, number, string[], number[], JSON object, etc. It will override existing values, if any.\n"
+        }
+      },
+      required: ["mode", "target", "value"]
+    },
+    CopyValueMapper: {
+      type: "object",
+      deprecated: true,
+      properties: {
+        mode: {
+          $ref: "#/components/schemas/MappingAttributeMode"
+        },
+        target: {
+          type: "string",
+          description: "JSON like target path for the attribute. Eg. last_name"
+        },
+        source: {
+          type: "string",
+          description: "JSON source path for the value to be extracted from the main entity. Eg: steps[1].['Product Info'].price\n"
+        }
+      },
+      required: ["mode", "target", "source"]
+    },
+    AppendValueMapper: {
+      type: "object",
+      deprecated: true,
+      properties: {
+        mode: {
+          $ref: "#/components/schemas/MappingAttributeMode"
+        },
+        target: {
+          type: "string",
+          description: "JSON like target path for the attribute. Eg. last_name"
+        },
+        source: {
+          type: "string",
+          description: "JSON source path for the value to be extracted from the main entity. Eg: steps[1].['Product Info'].price\n"
+        },
+        value_json: {
+          type: "string",
+          description: "To be provided only when mapping json objects into a target attribute. Eg array of addresses.\n"
+        },
+        target_unique: {
+          type: "array",
+          items: {
+            type: "string"
+          },
+          description: "Array of keys which should be used when checking for uniqueness. Eg: [country, city, postal_code]\n"
+        }
+      },
+      required: ["mode", "target", "value_json"]
+    },
+    MappingHistoryResp: {
+      type: "object",
+      properties: {
+        results: {
+          type: "array",
+          items: {
+            $ref: "#/components/schemas/MappingHistoryEntry"
+          }
+        }
+      },
+      required: ["results"]
+    },
+    MappingHistoryEntry: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          example: "70542580-2b38-4bfc-af8d-bb90102f9f47"
+        },
+        timestamp: {
+          type: "string",
+          format: "ISO datetime"
+        },
+        source_entity_snapshot: {
+          $ref: "#/components/schemas/Entity"
+        },
+        mapped_entities_snapshot: {
+          type: "array",
+          items: {
+            $ref: "#/components/schemas/Entity"
+          }
+        },
+        target_configs_snapshot: {
+          type: "array",
+          items: {
+            $ref: "#/components/schemas/TargetConfig"
+          }
+        }
+      },
+      required: ["id", "timestamp", "source_entity_snapshot", "target_configs_snapshot", "mapped_entities_snapshot"]
+    },
+    MappingSource: {
+      type: "object",
+      properties: {
+        key: {
+          type: "string",
+          description: "Key aiming to identify source"
+        },
+        sub_properties: {
+          description: "Each item describes a property under the main source and a possibly, a default value for its target attribute",
+          type: "array",
+          items: {
+            $ref: "#/components/schemas/MappingSourceProperty"
+          }
+        },
+        source_type: {
+          type: "string",
+          description: "Data Structure type of source"
+        },
+        group: {
+          type: "string",
+          description: "A group this source belongs to. Used for grouping sources in the UI"
+        },
+        possible_target_types: {
+          type: "array",
+          items: {
+            $ref: "#/components/schemas/MappingSourceTargetType"
+          },
+          description: "Data Structure Type of the underlaying output value"
+        },
+        initial_relation: {
+          description: "Initial value of a relation to be added",
+          $ref: "#/components/schemas/RelationAttribute"
+        },
+        title: {
+          type: "string",
+          description: "Human readable name of the Source"
+        },
+        sub_title: {
+          type: "string",
+          description: "Human readable type of the source"
+        },
+        repeatable: {
+          type: "boolean",
+          description: "Whether the source (block or attribute) is a repeatable, aka holds a list of values"
+        },
+        target_settings: {
+          type: "object",
+          properties: {
+            allowed_ui_actions: {
+              type: "array",
+              items: {
+                type: "string",
+                enum: ["schema-select", "attribute-select", "target-delete", "target-add", "target"]
+              },
+              description: "Describes which actions the user can perform on each target, if specified. If not specified, all actions are allowed"
+            },
+            locked: {
+              type: "string",
+              enum: ["each", "first", "system_recommendation"],
+              description: "Whether its a read-only ui or not. Can be each target, or only the first. Overwrites uiActions"
+            },
+            isSingleTarget: {
+              type: "boolean",
+              description: "Whether all source mappings flow into a single attribute (e.g. address)"
+            },
+            visibility: {
+              description: "Determines whether a mapping target should be shown or not. Use if there are targets which cannot be manipulated by the UI. E.g journey_data",
+              type: "object",
+              properties: {
+                mode: {
+                  type: "string",
+                  enum: ["hide", "show", "message"]
+                },
+                if: {
+                  type: "object",
+                  additionalProperties: {
+                    type: "string"
+                  }
+                },
+                message: {
+                  type: "string"
+                }
+              },
+              required: ["mode", "if"]
+            }
+          }
+        }
+      },
+      required: ["key", "title", "source_type"]
+    },
+    MappingSourceProperty: {
+      type: "object",
+      properties: {
+        value: {
+          type: "string"
+        },
+        label: {
+          type: "string"
+        },
+        initial_target_value: {
+          type: "string"
+        },
+        possible_target_types: {
+          type: "array",
+          items: {
+            $ref: "#/components/schemas/MappingSourceTargetType"
+          },
+          description: "Data Structure Type of the underlaying output value"
+        },
+        raw: {
+          type: "boolean",
+          description: "Whether the raw value should be used, or whether the value is enriched by a path"
+        }
+      },
+      required: ["value", "label"]
+    },
+    MappingSourceTargetType: {
+      type: "string",
+      enum: [
+        "string",
+        "date",
+        "datetime",
+        "boolean",
+        "number",
+        "image",
+        "file",
+        "address",
+        "email",
+        "phone",
+        "select",
+        "multiselect",
+        "payment",
+        "link",
+        "currency",
+        "sequence",
+        "relation",
+        "array"
+      ]
+    }
+  }
+};
+var servers = [
+  {
+    url: "https://entity-mapping.sls.epilot.io"
+  }
+];
+var entity_mapping_default = {
+  openapi,
+  info,
+  tags,
+  security,
+  paths,
+  components,
+  servers
+};
+export {
+  components,
+  entity_mapping_default as default,
+  info,
+  openapi,
+  paths,
+  security,
+  servers,
+  tags
+};