---
updatedAt: 2026-09-02T17:35:26.000Z
agentTools:
  projectIndex: https://docs.go.v7labs.com/llms.txt
---

# Create an Export

Creates a new export

**Note:** `project_id` is the same as `agent_id`

# OpenAPI definition

```json
{
  "components": {
    "schemas": {
      "Common.APIErrorDetails": {
        "description": "Additional structured error context. Shape varies by error code.\n\n- For conflict errors: contains a `conflicts` array with conflicting resources\n- For other errors: may contain arbitrary error-specific context",
        "nullable": true,
        "oneOf": [
          {
            "$ref": "#/components/schemas/Common.ConflictErrorDetails"
          },
          {
            "additionalProperties": true,
            "description": "Generic error details for non-conflict errors",
            "type": "object",
            "x-struct": null,
            "x-validate": null
          }
        ],
        "title": "Common.APIErrorDetails",
        "x-struct": "Elixir.AgiDbWeb.Schemas.Common.APIErrorDetails",
        "x-validate": null
      },
      "EntityFilters.NullableFilter": {
        "description": "Filter can be `simple` or `group`. If you want to filter by one `subject` eg. `item name`. You can specify `simple filter` for given `subject` and `matcher`. For more details please see details of `item name filter` or other simple filters. If you want to to filter item by more than one filter You need to use `group filter` which gives possibility to join `filters` using `and`, `or` operators.",
        "oneOf": [
          {
            "$ref": "#/components/schemas/EntityFilters.GroupFilter"
          },
          {
            "$ref": "#/components/schemas/EntityFilters.SimpleFilter"
          },
          {
            "$ref": "#/components/schemas/EntityFilters.NullableOrEmptyObject"
          }
        ],
        "title": "EntityFilters.NullableFilter",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.NullableFilter",
        "x-validate": null
      },
      "Exports.Format": {
        "default": "csv",
        "enum": [
          "csv",
          "xlsx"
        ],
        "title": "Exports.Format",
        "type": "string",
        "x-struct": "Elixir.AgiDbWeb.Schemas.Exports.Format",
        "x-validate": null
      },
      "EntityFilters.ActivateViewId.AnyOf": {
        "additionalProperties": false,
        "description": "Matches items based on whether the values from the subject have any of the values specified in the filter",
        "properties": {
          "name": {
            "enum": [
              "any_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "$ref": "#/components/schemas/Common.UUID"
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "values"
        ],
        "title": "EntityFilters.ActivateViewId.AnyOf",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.ActivateViewId.AnyOf",
        "x-validate": null
      },
      "PropertyContainsAnyOf": {
        "additionalProperties": false,
        "description": "Matches items based on whether the values from the subject contains the one specified in the filter",
        "properties": {
          "case_sensitive": {
            "default": true,
            "type": "boolean",
            "x-struct": null,
            "x-validate": null
          },
          "name": {
            "enum": [
              "property_contains_any_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "property_id": {
            "$ref": "#/components/schemas/Common.UUID"
          },
          "reference_support_via_property_id": {
            "nullable": true,
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "type": "string",
              "x-struct": null,
              "x-validate": null
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "property_id",
          "values"
        ],
        "title": "PropertyContainsAnyOf",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldTextValue.PropertyContainsAnyOf",
        "x-validate": null
      },
      "EntityFilters.SimpleFilter": {
        "description": "Simple filter specifies rule that subject has to fulfill. Each simple filter consist of `subject` and `matcher`. Subject is name of property you want to filter on. For example if you want to filter by entity id you should specify {subject: 'entity_id'}. Next you have to specify matcher which defines how you would like to filer. If you are interested in any of entities within array of entity ids you should specify: {matcher: {name: 'any_of', values: [list of entity ids]}}",
        "oneOf": [
          {
            "$ref": "#/components/schemas/ActivateViewId"
          },
          {
            "$ref": "#/components/schemas/EntityId"
          },
          {
            "$ref": "#/components/schemas/EntityStatus"
          },
          {
            "$ref": "#/components/schemas/FieldSelectOptionValue"
          },
          {
            "$ref": "#/components/schemas/FieldTextValue"
          },
          {
            "$ref": "#/components/schemas/ParentEntityId"
          },
          {
            "$ref": "#/components/schemas/EntityReviewStatus"
          },
          {
            "$ref": "#/components/schemas/FieldStatus"
          },
          {
            "$ref": "#/components/schemas/FieldFileName"
          },
          {
            "$ref": "#/components/schemas/FieldMetadataFieldName"
          },
          {
            "$ref": "#/components/schemas/FieldNumberValue"
          },
          {
            "$ref": "#/components/schemas/FieldDatetimeValue"
          },
          {
            "$ref": "#/components/schemas/FieldNumberUnit"
          },
          {
            "$ref": "#/components/schemas/Id"
          },
          {
            "$ref": "#/components/schemas/SelectOptionValue"
          },
          {
            "$ref": "#/components/schemas/TextValue"
          },
          {
            "$ref": "#/components/schemas/Status"
          }
        ],
        "title": "EntityFilters.SimpleFilter",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.SimpleFilter",
        "x-validate": null
      },
      "Common.ConflictErrorDetails": {
        "additionalProperties": false,
        "description": "Details for conflict errors",
        "properties": {
          "conflicts": {
            "description": "List of conflicting resources",
            "items": {
              "additionalProperties": true,
              "type": "object",
              "x-struct": null,
              "x-validate": null
            },
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "conflicts"
        ],
        "title": "Common.ConflictErrorDetails",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.Common.ConflictErrorDetails",
        "x-validate": null
      },
      "EntityFilters.EntityReviewStatus.NoneOf": {
        "additionalProperties": false,
        "description": "Matches items based on whether the values from the subject have none of the values specified in the filter",
        "properties": {
          "name": {
            "enum": [
              "none_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "$ref": "#/components/schemas/Projects.Common.FieldReviewStatus"
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "values"
        ],
        "title": "EntityFilters.EntityReviewStatus.NoneOf",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.EntityReviewStatus.NoneOf",
        "x-validate": null
      },
      "ActivateViewId": {
        "additionalProperties": false,
        "description": "Filter entities based on active view id",
        "properties": {
          "matcher": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/EntityFilters.ActivateViewId.AnyOf"
              },
              {
                "$ref": "#/components/schemas/EntityFilters.ActivateViewId.NoneOf"
              }
            ],
            "x-struct": null,
            "x-validate": null
          },
          "subject": {
            "enum": [
              "active_view_id"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "subject",
          "matcher"
        ],
        "title": "ActivateViewId",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.ActivateViewId",
        "x-validate": null
      },
      "PropertyNoneOfString": {
        "additionalProperties": false,
        "description": "Matches items based on whether the none of the values in the filter exist in the subject",
        "properties": {
          "case_sensitive": {
            "default": true,
            "type": "boolean",
            "x-struct": null,
            "x-validate": null
          },
          "name": {
            "enum": [
              "property_none_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "property_id": {
            "$ref": "#/components/schemas/Common.UUID"
          },
          "reference_support_via_property_id": {
            "nullable": true,
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "type": "string",
              "x-struct": null,
              "x-validate": null
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "property_id",
          "values"
        ],
        "title": "PropertyNoneOfString",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldSelectOptionValue.PropertyNoneOf",
        "x-validate": null
      },
      "PropertyLessThanOrEqualTo": {
        "additionalProperties": false,
        "description": "Matches items based on whether the values from the subject are less than or equal to the one specified in the filter",
        "properties": {
          "name": {
            "enum": [
              "property_less_than_or_equal_to"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "property_id": {
            "$ref": "#/components/schemas/Common.UUID"
          },
          "reference_support_via_property_id": {
            "nullable": true,
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "value": {
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "property_id",
          "value"
        ],
        "title": "PropertyLessThanOrEqualTo",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldNumberValue.PropertyLessThanOrEqualTo",
        "x-validate": null
      },
      "ViewAllOfFieldStatuses": {
        "additionalProperties": false,
        "description": "Matches items in a view based on whether all of their field statuses are in the filter values",
        "properties": {
          "name": {
            "enum": [
              "view_all_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "$ref": "#/components/schemas/Projects.ListEntities.FieldStatus"
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          },
          "view_id": {
            "$ref": "#/components/schemas/Common.UUID"
          }
        },
        "required": [
          "name",
          "view_id",
          "values"
        ],
        "title": "ViewAllOfFieldStatuses",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.EntityStatus.ViewAllOf",
        "x-validate": null
      },
      "EntityFilters.ParentEntityId.AnyOf": {
        "additionalProperties": false,
        "description": "Matches items based on whether the values from the subject have any of the values specified in the filter",
        "properties": {
          "name": {
            "enum": [
              "any_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "$ref": "#/components/schemas/Common.UUID"
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "values"
        ],
        "title": "EntityFilters.ParentEntityId.AnyOf",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.ParentEntityId.AnyOf",
        "x-validate": null
      },
      "EntityFilters.Filter": {
        "description": "Filter can be `simple` or `group`. If you want to filter by one `subject` eg. `item name`. You can specify `simple filter` for given `subject` and `matcher`. For more details please see details of `item name filter` or other simple filters. If you want to to filter item by more than one filter You need to use `group filter` which gives possibility to join `filters` using `and`, `or` operators.",
        "oneOf": [
          {
            "$ref": "#/components/schemas/EntityFilters.GroupFilter"
          },
          {
            "$ref": "#/components/schemas/EntityFilters.SimpleFilter"
          }
        ],
        "title": "EntityFilters.Filter",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.Filter",
        "x-validate": null
      },
      "Common.UUID": {
        "example": "e23ff3f3-8f77-4e78-9e81-fdb25abfb781",
        "format": "uuid",
        "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$",
        "title": "Common.UUID",
        "type": "string",
        "x-struct": null,
        "x-validate": null
      },
      "EntityFilters.NullableOrEmptyObject": {
        "additionalProperties": false,
        "nullable": true,
        "properties": {},
        "title": "EntityFilters.NullableOrEmptyObject",
        "type": "object",
        "x-struct": null,
        "x-validate": null
      },
      "PropertyAnyOfString": {
        "additionalProperties": false,
        "description": "Matches items based on whether the values from the subject are in the values specified in the filter",
        "properties": {
          "case_sensitive": {
            "default": true,
            "type": "boolean",
            "x-struct": null,
            "x-validate": null
          },
          "name": {
            "enum": [
              "property_any_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "property_id": {
            "$ref": "#/components/schemas/Common.UUID"
          },
          "reference_support_via_property_id": {
            "nullable": true,
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "type": "string",
              "x-struct": null,
              "x-validate": null
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "property_id",
          "values"
        ],
        "title": "PropertyAnyOfString",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldSelectOptionValue.PropertyAnyOf",
        "x-validate": null
      },
      "PropertyContainsNoneOf": {
        "additionalProperties": false,
        "description": "Matches items based on whether the values from the subject contains the one specified in the filter",
        "properties": {
          "case_sensitive": {
            "default": true,
            "type": "boolean",
            "x-struct": null,
            "x-validate": null
          },
          "name": {
            "enum": [
              "property_contains_none_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "property_id": {
            "$ref": "#/components/schemas/Common.UUID"
          },
          "reference_support_via_property_id": {
            "nullable": true,
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "type": "string",
              "x-struct": null,
              "x-validate": null
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "property_id",
          "values"
        ],
        "title": "PropertyContainsNoneOf",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldTextValue.PropertyContainsNoneOf",
        "x-validate": null
      },
      "Status": {
        "additionalProperties": false,
        "deprecated": true,
        "description": "DEPRECATED: Use FieldStatus instead",
        "properties": {
          "matcher": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/PropertyAnyOfFieldStatus"
              },
              {
                "$ref": "#/components/schemas/PropertyNoneOfFieldStatus"
              }
            ],
            "x-struct": null,
            "x-validate": null
          },
          "subject": {
            "enum": [
              "status"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "subject",
          "matcher"
        ],
        "title": "Status",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.Status",
        "x-validate": null
      },
      "ParentEntityId": {
        "additionalProperties": false,
        "description": "Filter entities based on parent entity id",
        "properties": {
          "matcher": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/EntityFilters.ParentEntityId.AnyOf"
              },
              {
                "$ref": "#/components/schemas/EntityFilters.ParentEntityId.NoneOf"
              }
            ],
            "x-struct": null,
            "x-validate": null
          },
          "subject": {
            "enum": [
              "parent_entity_id"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "subject",
          "matcher"
        ],
        "title": "ParentEntityId",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.ParentEntityId",
        "x-validate": null
      },
      "EntityFilters.EntityId.AnyOf": {
        "additionalProperties": false,
        "description": "Matches items based on whether the values from the subject have any of the values specified in the filter",
        "properties": {
          "name": {
            "enum": [
              "any_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "$ref": "#/components/schemas/Common.UUID"
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "values"
        ],
        "title": "EntityFilters.EntityId.AnyOf",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.EntityId.AnyOf",
        "x-validate": null
      },
      "PropertyLessThan": {
        "additionalProperties": false,
        "description": "Matches items based on whether the values from the subject are less than the one specified in the filter",
        "properties": {
          "name": {
            "enum": [
              "property_less_than"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "property_id": {
            "$ref": "#/components/schemas/Common.UUID"
          },
          "reference_support_via_property_id": {
            "nullable": true,
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "value": {
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "property_id",
          "value"
        ],
        "title": "PropertyLessThan",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldNumberValue.PropertyLessThan",
        "x-validate": null
      },
      "FieldNumberValue": {
        "additionalProperties": false,
        "description": "Filter entities based on field's number value.\nFor all matches except `property_any_of` and `property_none_of` matchers,\nthe value can contain a unit which will be used to pre-filter values, i.e.\n`100 EUR` will find all entities with a number value greater/equal/less than `100`\nbut only for values with unit `EUR`.\n",
        "properties": {
          "matcher": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/PropertyAnyOf"
              },
              {
                "$ref": "#/components/schemas/PropertyNoneOf"
              },
              {
                "$ref": "#/components/schemas/PropertyGreaterThan"
              },
              {
                "$ref": "#/components/schemas/PropertyLessThan"
              },
              {
                "$ref": "#/components/schemas/PropertyGreaterThanOrEqualTo"
              },
              {
                "$ref": "#/components/schemas/PropertyLessThanOrEqualTo"
              }
            ],
            "x-struct": null,
            "x-validate": null
          },
          "subject": {
            "enum": [
              "field_number_value"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "subject",
          "matcher"
        ],
        "title": "FieldNumberValue",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldNumberValue",
        "x-validate": null
      },
      "EntityFilters.GroupFilter": {
        "additionalProperties": false,
        "description": "Groups `simple` or `group filters` together with `or`, `and` operators. You have to specify at least one `filter`.",
        "properties": {
          "conjunction": {
            "$ref": "#/components/schemas/EntityFilters.Conjunction"
          },
          "filters": {
            "description": "List of `simple` or `group` filters",
            "items": {
              "$ref": "#/components/schemas/EntityFilters.Filter"
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "conjunction",
          "filters"
        ],
        "title": "EntityFilters.GroupFilter",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.GroupFilter",
        "x-validate": null
      },
      "PropertyAnyOfFieldStatus": {
        "additionalProperties": false,
        "description": "Matches items based on whether the values from the subject are in the values specified in the filter",
        "properties": {
          "case_sensitive": {
            "default": true,
            "type": "boolean",
            "x-struct": null,
            "x-validate": null
          },
          "name": {
            "enum": [
              "property_any_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "property_id": {
            "$ref": "#/components/schemas/Common.UUID"
          },
          "reference_support_via_property_id": {
            "nullable": true,
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "$ref": "#/components/schemas/Projects.ListEntities.FieldStatus"
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "property_id",
          "values"
        ],
        "title": "PropertyAnyOfFieldStatus",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldStatus.PropertyAnyOf",
        "x-validate": null
      },
      "FieldFileName": {
        "additionalProperties": false,
        "description": "Filter entities based on field's file name",
        "properties": {
          "matcher": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/PropertyAnyOf"
              },
              {
                "$ref": "#/components/schemas/PropertyNoneOf"
              },
              {
                "$ref": "#/components/schemas/PropertyContainsAnyOf"
              },
              {
                "$ref": "#/components/schemas/PropertyContainsNoneOf"
              }
            ],
            "x-struct": null,
            "x-validate": null
          },
          "subject": {
            "enum": [
              "field_file_name"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "subject",
          "matcher"
        ],
        "title": "FieldFileName",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldFileName",
        "x-validate": null
      },
      "PropertyAnyOf": {
        "additionalProperties": false,
        "description": "Matches items based on whether the values from the subject are in the values specified in the filter",
        "properties": {
          "case_sensitive": {
            "default": true,
            "type": "boolean",
            "x-struct": null,
            "x-validate": null
          },
          "name": {
            "enum": [
              "property_any_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "property_id": {
            "$ref": "#/components/schemas/Common.UUID"
          },
          "reference_support_via_property_id": {
            "nullable": true,
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "type": "string",
              "x-struct": null,
              "x-validate": null
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "property_id",
          "values"
        ],
        "title": "PropertyAnyOf",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldFileName.PropertyAnyOf",
        "x-validate": null
      },
      "EntityStatus": {
        "additionalProperties": false,
        "description": "Filter entities based on their fields status",
        "properties": {
          "matcher": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/ViewAnyOfFieldStatuses"
              },
              {
                "$ref": "#/components/schemas/ViewNoneOfFieldStatuses"
              },
              {
                "$ref": "#/components/schemas/ViewAllOfFieldStatuses"
              }
            ],
            "x-struct": null,
            "x-validate": null
          },
          "subject": {
            "enum": [
              "entity_status"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "subject",
          "matcher"
        ],
        "title": "EntityStatus",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.EntityStatus",
        "x-validate": null
      },
      "Projects.ListEntities.FieldStatus": {
        "enum": [
          "idle",
          "uploading",
          "waiting",
          "computing",
          "complete",
          "error",
          "skip"
        ],
        "title": "Projects.ListEntities.FieldStatus",
        "type": "string",
        "x-struct": "Elixir.AgiDbWeb.Schemas.Projects.ListEntities.FieldStatus",
        "x-validate": null
      },
      "EntityReviewStatus": {
        "additionalProperties": false,
        "description": "Filter entities based on review status of their fields",
        "properties": {
          "matcher": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/EntityFilters.EntityReviewStatus.AnyOf"
              },
              {
                "$ref": "#/components/schemas/EntityFilters.EntityReviewStatus.NoneOf"
              }
            ],
            "x-struct": null,
            "x-validate": null
          },
          "subject": {
            "enum": [
              "entity_review_status"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "subject",
          "matcher"
        ],
        "title": "EntityReviewStatus",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.EntityReviewStatus",
        "x-validate": null
      },
      "PropertyContainsAnyOfString": {
        "additionalProperties": false,
        "description": "Matches items based on whether the values from the subject contains the one specified in the filter",
        "properties": {
          "case_sensitive": {
            "default": true,
            "type": "boolean",
            "x-struct": null,
            "x-validate": null
          },
          "name": {
            "enum": [
              "property_contains_any_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "property_id": {
            "$ref": "#/components/schemas/Common.UUID"
          },
          "reference_support_via_property_id": {
            "nullable": true,
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "type": "string",
              "x-struct": null,
              "x-validate": null
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "property_id",
          "values"
        ],
        "title": "PropertyContainsAnyOfString",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldMetadataFieldName.PropertyContainsAnyOf",
        "x-validate": null
      },
      "FieldMetadataFieldName": {
        "additionalProperties": false,
        "description": "Filter entities based on field's custom field name",
        "properties": {
          "matcher": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/PropertyAnyOfString"
              },
              {
                "$ref": "#/components/schemas/PropertyNoneOfString"
              },
              {
                "$ref": "#/components/schemas/PropertyContainsAnyOfString"
              },
              {
                "$ref": "#/components/schemas/PropertyContainsNoneOfString"
              }
            ],
            "x-struct": null,
            "x-validate": null
          },
          "subject": {
            "enum": [
              "field_metadata_field_name"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "subject",
          "matcher"
        ],
        "title": "FieldMetadataFieldName",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldMetadataFieldName",
        "x-validate": null
      },
      "EntityFilters.EntityReviewStatus.AnyOf": {
        "additionalProperties": false,
        "description": "Matches items based on whether the values from the subject have any of the values specified in the filter",
        "properties": {
          "name": {
            "enum": [
              "any_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "$ref": "#/components/schemas/Projects.Common.FieldReviewStatus"
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "values"
        ],
        "title": "EntityFilters.EntityReviewStatus.AnyOf",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.EntityReviewStatus.AnyOf",
        "x-validate": null
      },
      "SelectOptionValue": {
        "additionalProperties": false,
        "deprecated": true,
        "description": "DEPRECATED: Use FieldSelectOptionValue instead",
        "properties": {
          "matcher": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/PropertyAnyOfString"
              },
              {
                "$ref": "#/components/schemas/PropertyAllOfString"
              },
              {
                "$ref": "#/components/schemas/PropertyNoneOfString"
              }
            ],
            "x-struct": null,
            "x-validate": null
          },
          "subject": {
            "enum": [
              "select_option_value"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "subject",
          "matcher"
        ],
        "title": "SelectOptionValue",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.SelectOptionValue",
        "x-validate": null
      },
      "EntityFilters.Conjunction": {
        "description": "Use to join filters together. It is possible to join simple or group filters with `and`, `or` operators",
        "enum": [
          "and",
          "or"
        ],
        "title": "EntityFilters.Conjunction",
        "type": "string",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.Conjunction",
        "x-validate": null
      },
      "ViewAnyOfFieldStatuses": {
        "additionalProperties": false,
        "description": "Matches items in a view based on whether any of their field statuses are in the filter values",
        "properties": {
          "name": {
            "enum": [
              "view_any_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "$ref": "#/components/schemas/Projects.ListEntities.FieldStatus"
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          },
          "view_id": {
            "$ref": "#/components/schemas/Common.UUID"
          }
        },
        "required": [
          "name",
          "view_id",
          "values"
        ],
        "title": "ViewAnyOfFieldStatuses",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.EntityStatus.ViewAnyOf",
        "x-validate": null
      },
      "PropertyGreaterThan": {
        "additionalProperties": false,
        "description": "Matches items based on whether the values from the subject are greater than the one specified in the filter",
        "properties": {
          "name": {
            "enum": [
              "property_greater_than"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "property_id": {
            "$ref": "#/components/schemas/Common.UUID"
          },
          "reference_support_via_property_id": {
            "nullable": true,
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "value": {
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "property_id",
          "value"
        ],
        "title": "PropertyGreaterThan",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldNumberValue.PropertyGreaterThan",
        "x-validate": null
      },
      "EntityFilters.ParentEntityId.NoneOf": {
        "additionalProperties": false,
        "description": "Matches items based on whether the values from the subject have none of the values specified in the filter",
        "properties": {
          "name": {
            "enum": [
              "none_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "$ref": "#/components/schemas/Common.UUID"
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "values"
        ],
        "title": "EntityFilters.ParentEntityId.NoneOf",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.ParentEntityId.NoneOf",
        "x-validate": null
      },
      "FieldNumberUnit": {
        "additionalProperties": false,
        "description": "Filter entities based on field's number unit",
        "properties": {
          "matcher": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/PropertyAnyOfString"
              },
              {
                "$ref": "#/components/schemas/PropertyNoneOfString"
              }
            ],
            "x-struct": null,
            "x-validate": null
          },
          "subject": {
            "enum": [
              "field_number_unit"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "subject",
          "matcher"
        ],
        "title": "FieldNumberUnit",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldNumberUnit",
        "x-validate": null
      },
      "PropertyNoneOf": {
        "additionalProperties": false,
        "description": "Matches items based on whether the none of the values in the filter exist in the subject",
        "properties": {
          "case_sensitive": {
            "default": true,
            "type": "boolean",
            "x-struct": null,
            "x-validate": null
          },
          "name": {
            "enum": [
              "property_none_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "property_id": {
            "$ref": "#/components/schemas/Common.UUID"
          },
          "reference_support_via_property_id": {
            "nullable": true,
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "type": "string",
              "x-struct": null,
              "x-validate": null
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "property_id",
          "values"
        ],
        "title": "PropertyNoneOf",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldFileName.PropertyNoneOf",
        "x-validate": null
      },
      "Exports.CreateExportRequest": {
        "additionalProperties": false,
        "description": "Create export request",
        "properties": {
          "filter": {
            "$ref": "#/components/schemas/EntityFilters.NullableFilter"
          },
          "format": {
            "$ref": "#/components/schemas/Exports.Format"
          },
          "name": {
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name"
        ],
        "title": "Exports.CreateExportRequest",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.Exports.CreateExportRequest",
        "x-validate": null
      },
      "PropertyNoneOfFieldStatus": {
        "additionalProperties": false,
        "description": "Matches items based on whether the none of the values in the filter exist in the subject",
        "properties": {
          "case_sensitive": {
            "default": true,
            "type": "boolean",
            "x-struct": null,
            "x-validate": null
          },
          "name": {
            "enum": [
              "property_none_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "property_id": {
            "$ref": "#/components/schemas/Common.UUID"
          },
          "reference_support_via_property_id": {
            "nullable": true,
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "$ref": "#/components/schemas/Projects.ListEntities.FieldStatus"
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "property_id",
          "values"
        ],
        "title": "PropertyNoneOfFieldStatus",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldStatus.PropertyNoneOf",
        "x-validate": null
      },
      "Common.DateTime": {
        "description": "DateTime in RFC3339 format",
        "example": "2020-01-20T14:00:00Z",
        "format": "date-time",
        "title": "Common.DateTime",
        "type": "string",
        "x-struct": "Elixir.AgiDbWeb.Schemas.Common.DateTime",
        "x-validate": null
      },
      "FieldSelectOptionValue": {
        "additionalProperties": false,
        "description": "Filter entities based on field's select value",
        "properties": {
          "matcher": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/PropertyAnyOfString"
              },
              {
                "$ref": "#/components/schemas/PropertyAllOfString"
              },
              {
                "$ref": "#/components/schemas/PropertyNoneOfString"
              }
            ],
            "x-struct": null,
            "x-validate": null
          },
          "subject": {
            "enum": [
              "field_select_option_value"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "subject",
          "matcher"
        ],
        "title": "FieldSelectOptionValue",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldSelectOptionValue",
        "x-validate": null
      },
      "Common.APIError": {
        "additionalProperties": false,
        "properties": {
          "code": {
            "example": "bad_request",
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "details": {
            "$ref": "#/components/schemas/Common.APIErrorDetails"
          },
          "message": {
            "example": "Bad Request",
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "code",
          "message"
        ],
        "title": "Common.APIError",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.Common.APIError",
        "x-validate": null
      },
      "PropertyAllOfString": {
        "additionalProperties": false,
        "description": "Matches items based on whether the all the values in the filter exist in the subject",
        "properties": {
          "case_sensitive": {
            "default": true,
            "type": "boolean",
            "x-struct": null,
            "x-validate": null
          },
          "name": {
            "enum": [
              "property_all_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "property_id": {
            "$ref": "#/components/schemas/Common.UUID"
          },
          "reference_support_via_property_id": {
            "nullable": true,
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "type": "string",
              "x-struct": null,
              "x-validate": null
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "property_id",
          "values"
        ],
        "title": "PropertyAllOfString",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldSelectOptionValue.PropertyAllOf",
        "x-validate": null
      },
      "FieldStatus": {
        "additionalProperties": false,
        "description": "Filter entities based on a fields status",
        "properties": {
          "matcher": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/PropertyAnyOfFieldStatus"
              },
              {
                "$ref": "#/components/schemas/PropertyNoneOfFieldStatus"
              }
            ],
            "x-struct": null,
            "x-validate": null
          },
          "subject": {
            "enum": [
              "field_status"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "subject",
          "matcher"
        ],
        "title": "FieldStatus",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldStatus",
        "x-validate": null
      },
      "EntityFilters.EntityId.NoneOf": {
        "additionalProperties": false,
        "description": "Matches items based on whether the values from the subject have none of the values specified in the filter",
        "properties": {
          "name": {
            "enum": [
              "none_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "$ref": "#/components/schemas/Common.UUID"
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "values"
        ],
        "title": "EntityFilters.EntityId.NoneOf",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.EntityId.NoneOf",
        "x-validate": null
      },
      "Id": {
        "additionalProperties": false,
        "deprecated": true,
        "description": "DEPRECATED: Use EntityId instead",
        "properties": {
          "matcher": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/EntityFilters.EntityId.AnyOf"
              },
              {
                "$ref": "#/components/schemas/EntityFilters.EntityId.NoneOf"
              }
            ],
            "x-struct": null,
            "x-validate": null
          },
          "subject": {
            "enum": [
              "id"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "subject",
          "matcher"
        ],
        "title": "Id",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.Id",
        "x-validate": null
      },
      "PropertyGreaterThanOrEqualTo": {
        "additionalProperties": false,
        "description": "Matches items based on whether the values from the subject are greater than or equal to the one specified in the filter",
        "properties": {
          "name": {
            "enum": [
              "property_greater_than_or_equal_to"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "property_id": {
            "$ref": "#/components/schemas/Common.UUID"
          },
          "reference_support_via_property_id": {
            "nullable": true,
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "value": {
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "property_id",
          "value"
        ],
        "title": "PropertyGreaterThanOrEqualTo",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldNumberValue.PropertyGreaterThanOrEqualTo",
        "x-validate": null
      },
      "EntityFilters.ActivateViewId.NoneOf": {
        "additionalProperties": false,
        "description": "Matches items based on whether the values from the subject have none of the values specified in the filter",
        "properties": {
          "name": {
            "enum": [
              "none_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "$ref": "#/components/schemas/Common.UUID"
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "values"
        ],
        "title": "EntityFilters.ActivateViewId.NoneOf",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.ActivateViewId.NoneOf",
        "x-validate": null
      },
      "EntityId": {
        "additionalProperties": false,
        "description": "Filter entities based on entity id",
        "properties": {
          "matcher": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/EntityFilters.EntityId.AnyOf"
              },
              {
                "$ref": "#/components/schemas/EntityFilters.EntityId.NoneOf"
              }
            ],
            "x-struct": null,
            "x-validate": null
          },
          "subject": {
            "enum": [
              "entity_id"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "subject",
          "matcher"
        ],
        "title": "EntityId",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.EntityId",
        "x-validate": null
      },
      "FieldTextValue": {
        "additionalProperties": false,
        "description": "Filter entities based on field's text value",
        "properties": {
          "matcher": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/PropertyAnyOfString"
              },
              {
                "$ref": "#/components/schemas/PropertyNoneOfString"
              },
              {
                "$ref": "#/components/schemas/PropertyContainsAnyOf"
              },
              {
                "$ref": "#/components/schemas/PropertyContainsNoneOf"
              }
            ],
            "x-struct": null,
            "x-validate": null
          },
          "subject": {
            "enum": [
              "field_text_value"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "subject",
          "matcher"
        ],
        "title": "FieldTextValue",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldTextValue",
        "x-validate": null
      },
      "PropertyContainsNoneOfString": {
        "additionalProperties": false,
        "description": "Matches items based on whether the values from the subject contains the one specified in the filter",
        "properties": {
          "case_sensitive": {
            "default": true,
            "type": "boolean",
            "x-struct": null,
            "x-validate": null
          },
          "name": {
            "enum": [
              "property_contains_none_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "property_id": {
            "$ref": "#/components/schemas/Common.UUID"
          },
          "reference_support_via_property_id": {
            "nullable": true,
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "type": "string",
              "x-struct": null,
              "x-validate": null
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "name",
          "property_id",
          "values"
        ],
        "title": "PropertyContainsNoneOfString",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldMetadataFieldName.PropertyContainsNoneOf",
        "x-validate": null
      },
      "Exports.ExportResponse": {
        "additionalProperties": false,
        "description": "An export",
        "properties": {
          "format": {
            "$ref": "#/components/schemas/Exports.Format"
          },
          "id": {
            "$ref": "#/components/schemas/Common.UUID"
          },
          "inserted_at": {
            "$ref": "#/components/schemas/Common.DateTime"
          },
          "name": {
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "project_id": {
            "$ref": "#/components/schemas/Common.UUID"
          },
          "status": {
            "enum": [
              "pending",
              "complete",
              "error"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "updated_at": {
            "$ref": "#/components/schemas/Common.DateTime"
          },
          "url": {
            "nullable": true,
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "id",
          "project_id",
          "name",
          "url",
          "status",
          "inserted_at",
          "updated_at",
          "format"
        ],
        "title": "Exports.ExportResponse",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.Exports.ExportResponse",
        "x-validate": null
      },
      "Projects.Common.FieldReviewStatus": {
        "enum": [
          "pending",
          "approved",
          "rejected"
        ],
        "title": "Projects.Common.FieldReviewStatus",
        "type": "string",
        "x-struct": "Elixir.AgiDbWeb.Schemas.Projects.Common.FieldReviewStatus",
        "x-validate": null
      },
      "ViewNoneOfFieldStatuses": {
        "additionalProperties": false,
        "description": "Matches items in a view based on whether none of their field statuses are in the filter values",
        "properties": {
          "name": {
            "enum": [
              "view_none_of"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          },
          "values": {
            "items": {
              "$ref": "#/components/schemas/Projects.ListEntities.FieldStatus"
            },
            "minItems": 1,
            "type": "array",
            "x-struct": null,
            "x-validate": null
          },
          "view_id": {
            "$ref": "#/components/schemas/Common.UUID"
          }
        },
        "required": [
          "name",
          "view_id",
          "values"
        ],
        "title": "ViewNoneOfFieldStatuses",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.EntityStatus.ViewNoneOf",
        "x-validate": null
      },
      "FieldDatetimeValue": {
        "additionalProperties": false,
        "description": "Filter entities based on field's datetime value. All matchers support optional granularity for date_trunc truncation (year, quarter, month, day, hour, minute, second).",
        "properties": {
          "matcher": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/PropertyAnyOf"
              },
              {
                "$ref": "#/components/schemas/PropertyNoneOf"
              },
              {
                "$ref": "#/components/schemas/PropertyGreaterThan"
              },
              {
                "$ref": "#/components/schemas/PropertyLessThan"
              },
              {
                "$ref": "#/components/schemas/PropertyGreaterThanOrEqualTo"
              },
              {
                "$ref": "#/components/schemas/PropertyLessThanOrEqualTo"
              }
            ],
            "x-struct": null,
            "x-validate": null
          },
          "subject": {
            "enum": [
              "field_datetime_value"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "subject",
          "matcher"
        ],
        "title": "FieldDatetimeValue",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.FieldDatetimeValue",
        "x-validate": null
      },
      "TextValue": {
        "additionalProperties": false,
        "deprecated": true,
        "description": "DEPRECATED: Use FieldTextValue instead",
        "properties": {
          "matcher": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/PropertyAnyOfString"
              },
              {
                "$ref": "#/components/schemas/PropertyNoneOfString"
              },
              {
                "$ref": "#/components/schemas/PropertyContainsAnyOf"
              },
              {
                "$ref": "#/components/schemas/PropertyContainsNoneOf"
              }
            ],
            "x-struct": null,
            "x-validate": null
          },
          "subject": {
            "enum": [
              "text_value"
            ],
            "type": "string",
            "x-struct": null,
            "x-validate": null
          }
        },
        "required": [
          "subject",
          "matcher"
        ],
        "title": "TextValue",
        "type": "object",
        "x-struct": "Elixir.AgiDbWeb.Schemas.EntityFilters.TextValue",
        "x-validate": null
      }
    },
    "securitySchemes": {
      "ApiKeyAuth": {
        "in": "header",
        "name": "X-API-KEY",
        "type": "apiKey"
      },
      "BearerAuth": {
        "scheme": "bearer",
        "type": "http"
      }
    }
  },
  "info": {
    "title": "V7 Go API",
    "version": "0.1.0"
  },
  "openapi": "3.0.0",
  "paths": {
    "/api/workspaces/{workspace_id}/projects/{project_id}/exports": {
      "post": {
        "callbacks": {},
        "description": "Creates a new export",
        "operationId": "export-create",
        "parameters": [
          {
            "description": "",
            "in": "path",
            "name": "workspace_id",
            "required": true,
            "schema": {
              "$ref": "#/components/schemas/Common.UUID"
            }
          },
          {
            "description": "",
            "in": "path",
            "name": "project_id",
            "required": true,
            "schema": {
              "$ref": "#/components/schemas/Common.UUID"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/Exports.CreateExportRequest"
              }
            }
          },
          "description": "Exports.CreateExportRequest",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Exports.ExportResponse"
                }
              }
            },
            "description": "Exports.ExportResponse"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Common.APIError"
                }
              }
            },
            "description": "Common.APIError"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Common.APIError"
                }
              }
            },
            "description": "Common.APIError"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Common.APIError"
                }
              }
            },
            "description": "Common.APIError"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Common.APIError"
                }
              }
            },
            "description": "Common.APIError"
          },
          "409": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Common.APIError"
                }
              }
            },
            "description": "Common.APIError"
          },
          "422": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Common.APIError"
                }
              }
            },
            "description": "Common.APIError"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Common.APIError"
                }
              }
            },
            "description": "Common.APIError"
          }
        },
        "summary": "Create an Export",
        "tags": [
          "Exports"
        ]
      }
    }
  },
  "security": [
    {
      "BearerAuth": []
    },
    {
      "ApiKeyAuth": []
    }
  ],
  "servers": [
    {
      "description": "EU",
      "url": "https://go.v7labs.com",
      "variables": {}
    },
    {
      "description": "US",
      "url": "https://go.us.v7labs.com",
      "variables": {}
    },
    {
      "description": "UAE",
      "url": "https://go.uae.v7labs.com",
      "variables": {}
    }
  ]
}
```