> ## Documentation Index
> Fetch the complete documentation index at: https://docs.flowengineering.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Create a shared saved view

> Requires Admin access. Adds one view after the existing shared views, visible to every project member. Sets its structure (start type and nesting rules, by data type id) and optionally its table columns, filters and sort, each checked against the data model; display options are edited in Flow. An id that is already a shared view answers 409.



## OpenAPI

````yaml /openapi/customer-api.json post /project/{projectId}/views/saved
openapi: 3.0.0
info:
  contact: {}
  description: >-
    Flow customer API reference. Start with the [quickstart](/api/quickstart)
    and [authentication guide](/api/authentication).
  title: Customer API
  version: 1.0.0
servers:
  - description: Flow API
    url: '{baseUrl}'
    variables:
      baseUrl:
        default: https://backend.branch.flowengineering.com
security: []
tags:
  - name: Audit
  - name: Automations
  - name: Branches
  - name: Comments
  - name: Convert
  - name: Data Model
  - name: Diagrams
  - name: Entities
  - name: Events
  - name: Files
  - name: Import
  - name: Notifications
  - name: Persistent agents
  - name: Projects
  - name: ReqIF
  - name: ReqIF Import
  - name: Review policy
  - name: Shared Access Grants
  - name: User Groups
  - name: Users
  - name: Views
paths:
  /project/{projectId}/views/saved:
    post:
      tags:
        - Views
      summary: Create a shared saved view
      description: >-
        Requires Admin access. Adds one view after the existing shared views,
        visible to every project member. Sets its structure (start type and
        nesting rules, by data type id) and optionally its table columns,
        filters and sort, each checked against the data model; display options
        are edited in Flow. An id that is already a shared view answers 409.
      operationId: ViewsController_createSavedView
      parameters:
        - in: path
          name: projectId
          required: true
          schema:
            type: string
        - description: Workspace identifier
          in: header
          name: customer
          required: true
          schema:
            type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CreateSharedSavedViewDto'
        required: true
      responses:
        '201':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SharedSavedViewDto'
          description: ''
        '409':
          description: A shared view already has this id.
      security:
        - api-key: []
        - bearer: []
components:
  schemas:
    CreateSharedSavedViewDto:
      properties:
        columns:
          description: >-
            Table columns, in order. Replaces every column; [] leaves the view
            on the default columns. Stored as `state.columns`.
          items:
            $ref: '#/components/schemas/SavedViewColumnDto'
          type: array
        filters:
          allOf:
            - properties:
                nodes:
                  items:
                    anyOf:
                      - additionalProperties: false
                        properties:
                          id:
                            description: >-
                              Any string unique within the expression; Flow
                              assigns one when omitted.
                            minLength: 1
                            type: string
                          kind:
                            enum:
                              - group
                            type: string
                          nodes:
                            description: The same leaves as the top level; groups may nest.
                            items: {}
                            type: array
                          operator:
                            enum:
                              - and
                              - or
                            type: string
                        required:
                          - kind
                          - operator
                          - nodes
                        type: object
                      - anyOf:
                          - additionalProperties: false
                            properties:
                              fieldId:
                                type: string
                              id:
                                description: >-
                                  Any string unique within the expression; Flow
                                  assigns one when omitted.
                                minLength: 1
                                type: string
                              operation:
                                description: >-
                                  Value-agnostic presence check; supply no value
                                  operand.
                                enum:
                                  - isPopulated
                                  - isEmpty
                                type: string
                              type:
                                enum:
                                  - tag
                                  - stage
                                  - verificationResult
                                  - text
                                  - richText
                                  - number
                                  - date
                                  - user
                                type: string
                            required:
                              - type
                              - fieldId
                              - operation
                            type: object
                          - additionalProperties: false
                            properties:
                              fieldId:
                                type: string
                              id:
                                description: >-
                                  Any string unique within the expression; Flow
                                  assigns one when omitted.
                                minLength: 1
                                type: string
                              operation:
                                enum:
                                  - overlaps
                                  - excludes
                                type: string
                              tags:
                                items:
                                  type: string
                                type: array
                              type:
                                enum:
                                  - tag
                                  - stage
                                  - verificationResult
                                type: string
                            required:
                              - type
                              - fieldId
                              - operation
                              - tags
                            type: object
                          - additionalProperties: false
                            properties:
                              fieldId:
                                type: string
                              id:
                                description: >-
                                  Any string unique within the expression; Flow
                                  assigns one when omitted.
                                minLength: 1
                                type: string
                              operation:
                                enum:
                                  - equals
                                  - notEquals
                                  - contains
                                  - notContains
                                  - startsWith
                                  - endsWith
                                type: string
                              text:
                                type: string
                              type:
                                enum:
                                  - text
                                  - richText
                                type: string
                            required:
                              - type
                              - fieldId
                              - operation
                              - text
                            type: object
                          - additionalProperties: false
                            properties:
                              fieldId:
                                type: string
                              id:
                                description: >-
                                  Any string unique within the expression; Flow
                                  assigns one when omitted.
                                minLength: 1
                                type: string
                              operation:
                                enum:
                                  - equals
                                  - notEquals
                                  - greaterThan
                                  - greaterThanOrEqual
                                  - lessThan
                                  - lessThanOrEqual
                                  - between
                                type: string
                              type:
                                enum:
                                  - number
                                type: string
                              value:
                                type: string
                              valueTo:
                                type: string
                            required:
                              - type
                              - fieldId
                              - operation
                              - value
                            type: object
                          - additionalProperties: false
                            properties:
                              date:
                                nullable: true
                                type: string
                              dateTo:
                                nullable: true
                                type: string
                              fieldId:
                                type: string
                              id:
                                description: >-
                                  Any string unique within the expression; Flow
                                  assigns one when omitted.
                                minLength: 1
                                type: string
                              operation:
                                enum:
                                  - 'on'
                                  - before
                                  - after
                                  - between
                                type: string
                              type:
                                enum:
                                  - date
                                type: string
                            required:
                              - type
                              - fieldId
                              - operation
                              - date
                            type: object
                          - additionalProperties: false
                            properties:
                              date:
                                nullable: true
                                type: string
                              dateTo:
                                nullable: true
                                type: string
                              id:
                                description: >-
                                  Any string unique within the expression; Flow
                                  assigns one when omitted.
                                minLength: 1
                                type: string
                              operation:
                                enum:
                                  - 'on'
                                  - before
                                  - after
                                  - between
                                  - within
                                  - notWithin
                                type: string
                              range:
                                description: >-
                                  For within / notWithin: the rolling window
                                  ending now — the last 24 hours, 7, 30 or 90
                                  days.
                                enum:
                                  - day
                                  - week
                                  - month
                                  - quarter
                                nullable: true
                                type: string
                              timestamp:
                                description: >-
                                  Which lifecycle instant to compare: when the
                                  item was created, or when it last changed (any
                                  field or link edit visible on this branch).
                                enum:
                                  - createdAt
                                  - updatedAt
                                type: string
                              type:
                                enum:
                                  - timestamp
                                type: string
                            required:
                              - type
                              - timestamp
                              - operation
                              - date
                            type: object
                          - additionalProperties: false
                            properties:
                              fieldId:
                                type: string
                              id:
                                description: >-
                                  Any string unique within the expression; Flow
                                  assigns one when omitted.
                                minLength: 1
                                type: string
                              operation:
                                enum:
                                  - isTrue
                                  - isFalse
                                type: string
                              type:
                                enum:
                                  - toggle
                                type: string
                            required:
                              - type
                              - fieldId
                              - operation
                            type: object
                          - additionalProperties: false
                            properties:
                              fieldId:
                                type: string
                              id:
                                description: >-
                                  Any string unique within the expression; Flow
                                  assigns one when omitted.
                                minLength: 1
                                type: string
                              operation:
                                enum:
                                  - overlaps
                                  - excludes
                                type: string
                              type:
                                enum:
                                  - user
                                type: string
                              userIds:
                                items:
                                  type: string
                                type: array
                            required:
                              - type
                              - fieldId
                              - operation
                              - userIds
                            type: object
                          - additionalProperties: false
                            properties:
                              id:
                                description: >-
                                  Any string unique within the expression; Flow
                                  assigns one when omitted.
                                minLength: 1
                                type: string
                              operation:
                                enum:
                                  - overlaps
                                  - excludes
                                type: string
                              type:
                                enum:
                                  - type
                                type: string
                              typeIds:
                                items:
                                  type: string
                                type: array
                            required:
                              - type
                              - operation
                              - typeIds
                            type: object
                          - additionalProperties: false
                            properties:
                              fieldId:
                                type: string
                              fieldType:
                                enum:
                                  - jira
                                  - teamcenter
                                  - linear
                                  - googleDoc
                                  - googleSheet
                                  - aodocsDoc
                                  - file
                                  - cadFile
                                type: string
                              id:
                                description: >-
                                  Any string unique within the expression; Flow
                                  assigns one when omitted.
                                minLength: 1
                                type: string
                              operation:
                                enum:
                                  - isPopulated
                                  - isEmpty
                                type: string
                              type:
                                enum:
                                  - presence
                                type: string
                            required:
                              - type
                              - fieldId
                              - fieldType
                              - operation
                            type: object
                          - additionalProperties: false
                            properties:
                              id:
                                description: >-
                                  Any string unique within the expression; Flow
                                  assigns one when omitted.
                                minLength: 1
                                type: string
                              operation:
                                enum:
                                  - overlaps
                                  - excludes
                                type: string
                              type:
                                enum:
                                  - changedInBranch
                                type: string
                            required:
                              - type
                              - operation
                            type: object
                          - additionalProperties: false
                            properties:
                              id:
                                description: >-
                                  Any string unique within the expression; Flow
                                  assigns one when omitted.
                                minLength: 1
                                type: string
                              operation:
                                enum:
                                  - isPopulated
                                  - isEmpty
                                type: string
                              resolved:
                                enum:
                                  - open
                                  - resolved
                                type: string
                              type:
                                enum:
                                  - hasComments
                                type: string
                            required:
                              - type
                              - operation
                            type: object
                          - additionalProperties: false
                            properties:
                              id:
                                description: >-
                                  Any string unique within the expression; Flow
                                  assigns one when omitted.
                                minLength: 1
                                type: string
                              operation:
                                enum:
                                  - overlaps
                                  - excludes
                                type: string
                              resolved:
                                enum:
                                  - open
                                  - resolved
                                type: string
                              type:
                                enum:
                                  - commentBy
                                type: string
                              userIds:
                                items:
                                  type: string
                                type: array
                            required:
                              - type
                              - operation
                              - userIds
                            type: object
                          - additionalProperties: false
                            properties:
                              id:
                                description: >-
                                  Any string unique within the expression; Flow
                                  assigns one when omitted.
                                minLength: 1
                                type: string
                              operation:
                                enum:
                                  - contains
                                  - notContains
                                type: string
                              resolved:
                                enum:
                                  - open
                                  - resolved
                                type: string
                              text:
                                maxLength: 1000
                                type: string
                              type:
                                enum:
                                  - commentText
                                type: string
                            required:
                              - type
                              - operation
                              - text
                            type: object
                          - additionalProperties: false
                            properties:
                              fieldId:
                                nullable: true
                                type: string
                              id:
                                description: >-
                                  Any string unique within the expression; Flow
                                  assigns one when omitted.
                                minLength: 1
                                type: string
                              operation:
                                enum:
                                  - overlaps
                                  - excludes
                                type: string
                              resolved:
                                enum:
                                  - open
                                  - resolved
                                type: string
                              type:
                                enum:
                                  - commentField
                                type: string
                            required:
                              - type
                              - operation
                              - fieldId
                            type: object
                          - additionalProperties: false
                            properties:
                              id:
                                description: >-
                                  Any string unique within the expression; Flow
                                  assigns one when omitted.
                                minLength: 1
                                type: string
                              operation:
                                enum:
                                  - matches
                                type: string
                              text:
                                type: string
                              type:
                                enum:
                                  - search
                                type: string
                            required:
                              - type
                              - operation
                              - text
                            type: object
                          - additionalProperties: false
                            properties:
                              direction:
                                description: >-
                                  Which links count: `upstream` (inbound),
                                  `downstream` (outbound), `up+downstream`, or
                                  `cross-link`. Omit to count a link of any kind
                                  — inbound, outbound and cross-link alike —
                                  which is also what the view toolbar does with
                                  no direction set.
                                enum:
                                  - upstream
                                  - downstream
                                  - up+downstream
                                  - cross-link
                                type: string
                              entityId:
                                default: null
                                nullable: true
                                type: string
                              id:
                                description: >-
                                  Any string unique within the expression; Flow
                                  assigns one when omitted.
                                minLength: 1
                                type: string
                              operation:
                                enum:
                                  - overlaps
                                  - excludes
                                type: string
                              targetKind:
                                description: >-
                                  Whether the target is one entity (`entityId`)
                                  or any entity of a type (`typeId`). Inferred
                                  from which id is given when omitted.
                                enum:
                                  - entity
                                  - type
                                type: string
                              type:
                                enum:
                                  - linkedTo
                                type: string
                              typeId:
                                default: null
                                description: >-
                                  Entity-type reference for "linked to any
                                  entity of this type"; use the category form
                                  required by the calling tool.
                                nullable: true
                                type: string
                            required:
                              - type
                              - operation
                            type: object
                  type: array
                operator:
                  enum:
                    - and
                    - or
                  type: string
              required:
                - operator
                - nodes
              type: object
          description: >-
            Conditions every item the view shows must meet, joined by
            `operator`; a `group` node joins its own `nodes` with its own
            operator. Each leaf's `type` is the FIELD'S DATA TYPE (`tag`,
            `stage`, `verificationResult`, `text`, `richText`, `number`, `date`,
            `toggle`, `user`, `presence`) with `fieldId` a field key from the
            categories endpoint (or `<typeId>::<key>`), or a structural
            condition (`type`, `linkedTo`, `timestamp`, `changedInBranch`, the
            comment conditions). Tag, stage and verification values are option
            NAMES; user values are user ids; type ids are data type ids. Unknown
            fields, options, types or operations answer 400 and nothing is
            saved. Example — Status is Triage:
            {"operator":"and","nodes":[{"type":"tag","fieldId":"status","operation":"overlaps","tags":["Triage"]}]}.
            Stored as `state.filters`.
        icon:
          $ref: '#/components/schemas/SavedViewIconDto'
        id:
          description: >-
            Id for the new view: letters, digits, `.`, `_` and `-`, starting
            with a letter or digit. Supply one so a retry of an unknown outcome
            can be checked by reading it; omitted, Flow picks one.
          type: string
        name:
          type: string
        relationships:
          description: >-
            Nesting rules, in order: under each `parentType`, show items of
            `childType`. Replaces every rule; send [] to remove them all. Stored
            as `state.relationships`.
          items:
            $ref: '#/components/schemas/SavedViewRelationshipDto'
          type: array
        rootType:
          description: >-
            Data type id of the items the view starts from (its "Start type").
            Stored as `state.rootType`.
          type: string
        sort:
          description: >-
            Ordered sort keys, the first most significant. Replaces the whole
            sort; send [] for the natural order. Stored as `state.sort`.
          items:
            $ref: '#/components/schemas/SavedViewSortDto'
          type: array
      required:
        - name
      type: object
    SharedSavedViewDto:
      properties:
        icon:
          $ref: '#/components/schemas/SavedViewIconDto'
        id:
          type: string
        name:
          type: string
        position:
          description: Display order among the shared views.
          type: number
        state:
          additionalProperties: true
          description: >-
            The view configuration: `rootType`, `relationships`, `columns`,
            `filters` and `sort` as written here, plus display options edited in
            Flow.
          type: object
      required:
        - id
        - name
      type: object
    SavedViewColumnDto:
      properties:
        categories:
          description: >-
            Field columns only: the data type ids the column applies to. Omitted
            or empty, it applies to every type that carries the field. A `link`
            column takes none.
          items:
            type: string
          type: array
        key:
          description: >-
            Field key of the column: a key from the categories endpoint (`name`,
            `description`, `owner`, `reviewers`, `unique_entity_number` or a
            custom field key), `<typeId>::<key>` to pin one type's field, or a
            reserved key: `__createdAt` (Created), `__updatedAt` (Updated),
            `__entityType` (Type), `__hierarchyDepth` or `__itemLink`. Give
            exactly one of `key` and `link`.
          type: string
        link:
          allOf:
            - $ref: '#/components/schemas/SavedViewLinkColumnDto'
          description: A linked-items column instead of a field column.
        pinned:
          description: Keep the column pinned on the left of the table.
          type: boolean
        wrap:
          description: Wrap cell text onto several lines.
          type: boolean
      type: object
    SavedViewIconDto:
      properties:
        colour:
          description: Icon color, as data types use.
          type: string
        icon:
          description: Icon name, as data types use.
          type: string
      required:
        - icon
        - colour
      type: object
    SavedViewRelationshipDto:
      properties:
        childType:
          description: Data type id of the items shown under each parent.
          type: string
        direction:
          description: >-
            Which links the view follows from parent to child: `downstream` (the
            parent links to the child), `upstream` (the child links to the
            parent) or `both`. Defaults to `both`.
          enum:
            - upstream
            - downstream
            - both
          type: string
        parentType:
          description: Data type id of the parent.
          type: string
      required:
        - parentType
        - childType
      type: object
    SavedViewSortDto:
      properties:
        columnId:
          description: >-
            A column key as in `columns`: a field key or `<typeId>::<key>` ref;
            a reserved key (`name`, `__createdAt`, `__updatedAt`,
            `__entityType`, `__hierarchyDepth`). A linked-items column cannot be
            sorted by.
          type: string
        direction:
          enum:
            - asc
            - desc
          type: string
      required:
        - columnId
        - direction
      type: object
    SavedViewLinkColumnDto:
      properties:
        direction:
          description: >-
            Which links the column follows from the row: `downstream` (the row
            links to the item), `upstream` (the item links to the row),
            `up+downstream` or `cross-link`.
          enum:
            - up+downstream
            - cross-link
            - upstream
            - downstream
          type: string
        entityType:
          description: Data type id of the linked items the column lists.
          type: string
      required:
        - entityType
        - direction
      type: object
  securitySchemes:
    api-key:
      in: header
      name: X-API-Key
      type: apiKey
    bearer:
      bearerFormat: JWT
      scheme: bearer
      type: http

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.