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

# List cards assigned to you across projects

> Returns an offset-paginated page of cards assigned to the caller, across
every project where the caller currently holds card read access. Cards in
projects the caller can no longer read are left out rather than reported.
Accepts a personal access token with `cards:read` (or a scope that implies
it) or a browser session access token; execution grants are refused. A
token's permission ceiling applies here as on the project card routes:
projects where it does not allow card read are left out.

`isOpen` picks the card set: open (default), closed, or both. Values within
one repeated or comma-separated filter are ORed; distinct filter dimensions
are ANDed. The singular `projectId`, `teamId`, and `assigneeId` merge into
their plural lists. `includeNoTeam` extends the team facet with cards having
no team placement. Deadline and effort bounds are inclusive; within either
range, its include-no-value flag ORs null-valued cards with bounded
matches, and using only the flag matches only null-valued cards. Reversed
ranges return `INVALID_CARD_DEADLINE_RANGE` or `INVALID_CARD_EFFORT_RANGE`.

`stats` always counts the caller's open accessible cards and ignores every
filter and `isOpen`. Its day boundaries follow `timeZone` when it is sent;
deadlines themselves stay UTC instants. `filterOptions` lists the facet values present across
the caller's accessible cards in the selected `isOpen` set, unaffected by
the other filters, so a picker does not empty itself as filters narrow.




## OpenAPI

````yaml /openapi/davinci-public.v2.yaml get /api/v2/users/me/cards
openapi: 3.1.0
info:
  title: Davinci Public API
  version: 2.0.0
  description: >
    Public Routing Server API contract for Davinci integrations and official
    SDKs.


    Most operations live on the canonical `/api/v2/projects` mount and accept a

    personal access token (`dav_ak_live_…` / `dav_ak_test_…`) or browser access

    token. Evaluation-run creation is the deliberate exception: it accepts only
    a

    `purpose=automation` grant issued to a running Code execution.

    Project membership and role are checked on every user call, and an API key
    is

    additionally bounded by the permission ceiling derived from its scopes — a
    key

    can never exceed what its owner can do, and usually does less.


    Collaboration operations (invitations, membership changes, ownership
    transfer)

    are deliberately absent: they require a browser session and are not part of
    the

    programmatic surface.


    ## Two planes


    Most operations are **control plane**: they run on the Routing Server, take

    small requests, and answer quickly. A few are **data plane**, marked

    `x-plane: data`, and go straight to the machine holding your project — the
    only

    practical way to move multi-gigabyte files or hold a connection open for
    half

    an hour.


    Data-plane operations use a different host and a different credential.
    Create a

    session on a project and it returns both: a `dataPlane.url` to send to and a

    short-lived `dataPlane.token` (`dav_gr_…`, a *grant*) to send with. A grant

    reaches exactly one project, carries no more permission than the key that

    minted it, expires in minutes, and dies when its session closes. It is not

    interchangeable with an API key in either direction.


    The data-plane host never names a specific machine, so a project that moves

    between machines mid-session stays reachable at the same URL.
servers:
  - url: https://davinci-app.com
    description: Production (control plane)
  - url: https://davinci-app.com/data
    description: >-
      Production (data plane). Serves the operations marked `x-plane: data`,
      using a session's grant rather than an API key.
security:
  - ApiKeyBearer: []
tags:
  - name: Projects
    description: >-
      Create, inspect, open, close, and delete projects, and manage their
      attached files.
  - name: Content
    description: >
      Read and write the objects a project is made of. These reach the running

      project rather than storage, so they see uncommitted work — and so they
      open

      the project if it is not already open.
  - name: Branches
    description: >
      Branches, commits, and the history of a single object. A commit captures
      the

      running project's state, so these operations need the branch loaded, which
      they

      arrange for the caller.
  - name: Sessions
    description: >
      A session opens a project, holds it open, and issues the grant that
      reaches the

      data plane. It is the programmatic equivalent of having a project open in
      a

      browser tab: while it lives, the project stays loaded.


      It is also where the agent lives. Send it a prompt, read its status from
      the

      session, read the transcript back, and stop a run that is going the wrong
      way.
  - name: Chats
    description: >
      Your persistent conversations with a project's agent. A chat outlives the

      session it was started in: list your chats, read any of them back, move a

      session into one to carry on where it left off, and delete the ones you
      are

      done with.


      A new session starts in a fresh chat, whose id is in the session's
      `chatId`.

      A chat is only stored once something is sent in it, so a session that
      never

      sends a message leaves nothing behind. A run keeps going after its session

      moves to another chat, so one session can have several chats working at

      once. Name a chat's `chatId` on `sendAgentMessage` or `stopAgent` to reach
      it

      without moving the session; `agent.chats` on the session read reports
      every

      chat the session has a run in. A chat belongs to one session at a time;

      moving a session into a chat another session has, or sending in it, takes
      it

      over, and if that other session was in it, it continues in a fresh chat of

      its own.


      These are the chats started through the API — from the SDKs, a terminal,
      or

      an app built on them. Chats started in the Davinci web app are a separate
      set

      and do not appear here. These chats do appear in the web app, though,
      where

      you can watch a session work in one and take it over (see
      `switchSessionChat`).
  - name: AgentModels
    description: >
      Chat models available to your account. The returned keys are the values
      accepted

      by the session message API; availability follows your subscription,
      tenant, and

      any profile assigned to your account.
  - name: Tools
    description: >
      Invoke one of the agent's tools yourself, without the agent. Useful when
      you

      already know the operation you want and do not need a model to choose it —
      and

      when you want a deterministic result rather than an interpreted one.


      A tool is still held to the permissions of the credential invoking it, so
      a

      key cannot reach through a tool to something its scopes exclude.
  - name: Files
    description: >
      Data-plane file transfer. These reach your project's machine directly
      using a

      session's grant, which is what allows request bodies far larger than the

      control plane accepts.
  - name: Usage
    description: >
      What your models cost, broken down by model, project, session, or day.
      These

      read the usage ledger, which records one event per completed provider call
      —

      not your balances and limits, which are `/api/v2/users/me/accounting`.


      Usage is reported on an interval rather than per call, so a run that is
      still

      going may not be fully counted yet. Every response carries `asOf`, the
      moment

      the newest counted event was recorded, so you can see how current a total
      is

      instead of guessing.


      This is separate from `projects:read` on purpose: a key that reads your

      project data is not thereby allowed to see what you spend.
  - name: Evaluations
    description: |
      Lifecycle for the ephemeral target sandbox an evaluation runs against.
      Creation is available only to a `purpose=automation` grant issued to a
      running Code execution, so a sandbox always belongs to code rather than to
      a person's key. It returns a second, `purpose=evaluation` grant bound to
      the new sandbox; it never upgrades or replaces the source credential.
  - name: Tests
    description: >
      Asynchronously run an authored Test. The Test executes its linked Code

      object and applies its native evaluation criteria to derive the verdict.

      This is one way to start Code, not a prerequisite for anything the Code
      can

      do: the same function called directly holds the same authority.
  - name: Organizations
    description: Discover organizations available as containers for team planning.
  - name: Cards
    description: >
      Project-scoped agile cards, their index hierarchy, comments, tags,
      assignees,

      card dependencies, and design-object references, plus the caller's
      assigned

      cards across projects. Project access is checked on every call; an

      inaccessible project is reported as not found.
  - name: Teams
    description: >
      Organization-scoped team boards, linked projects, workflow columns,
      sprints,

      analytics, and card placements. Team visibility is privacy preserving:

      inaccessible organizations, private teams, and cross-organization ids are

      reported as not found rather than revealing that they exist.
paths:
  /api/v2/users/me/cards:
    get:
      tags:
        - Cards
      summary: List cards assigned to you across projects
      description: >
        Returns an offset-paginated page of cards assigned to the caller, across

        every project where the caller currently holds card read access. Cards
        in

        projects the caller can no longer read are left out rather than
        reported.

        Accepts a personal access token with `cards:read` (or a scope that
        implies

        it) or a browser session access token; execution grants are refused. A

        token's permission ceiling applies here as on the project card routes:

        projects where it does not allow card read are left out.


        `isOpen` picks the card set: open (default), closed, or both. Values
        within

        one repeated or comma-separated filter are ORed; distinct filter
        dimensions

        are ANDed. The singular `projectId`, `teamId`, and `assigneeId` merge
        into

        their plural lists. `includeNoTeam` extends the team facet with cards
        having

        no team placement. Deadline and effort bounds are inclusive; within
        either

        range, its include-no-value flag ORs null-valued cards with bounded

        matches, and using only the flag matches only null-valued cards.
        Reversed

        ranges return `INVALID_CARD_DEADLINE_RANGE` or
        `INVALID_CARD_EFFORT_RANGE`.


        `stats` always counts the caller's open accessible cards and ignores
        every

        filter and `isOpen`. Its day boundaries follow `timeZone` when it is
        sent;

        deadlines themselves stay UTC instants. `filterOptions` lists the facet
        values present across

        the caller's accessible cards in the selected `isOpen` set, unaffected
        by

        the other filters, so a picker does not empty itself as filters narrow.
      operationId: listMyCards
      parameters:
        - $ref: '#/components/parameters/MyCardsIsOpen'
        - $ref: '#/components/parameters/MyCardsPageLimit'
        - $ref: '#/components/parameters/PageOffset'
        - $ref: '#/components/parameters/MyCardsQuery'
        - $ref: '#/components/parameters/MyCardsProjectId'
        - $ref: '#/components/parameters/MyCardsProjectIds'
        - $ref: '#/components/parameters/MyCardsTeamId'
        - $ref: '#/components/parameters/CardTeamIds'
        - $ref: '#/components/parameters/CardStatusIds'
        - $ref: '#/components/parameters/CardSprintIds'
        - $ref: '#/components/parameters/MyCardsAssigneeId'
        - $ref: '#/components/parameters/CardAssigneeIds'
        - $ref: '#/components/parameters/CardTagIds'
        - $ref: '#/components/parameters/CardIncludeNoTeam'
        - $ref: '#/components/parameters/CardDeadlineFrom'
        - $ref: '#/components/parameters/CardDeadlineTo'
        - $ref: '#/components/parameters/CardIncludeNoDeadline'
        - $ref: '#/components/parameters/CardEffortMin'
        - $ref: '#/components/parameters/CardEffortMax'
        - $ref: '#/components/parameters/CardIncludeNoEffort'
        - $ref: '#/components/parameters/MyCardsSort'
        - $ref: '#/components/parameters/MyCardsTimeZone'
      responses:
        '200':
          description: >-
            One page of the caller's assigned cards with dashboard counters and
            facets.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MyCardsResponse'
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/Forbidden'
        '429':
          $ref: '#/components/responses/RateLimited'
        '500':
          $ref: '#/components/responses/InternalError'
      security:
        - ApiKeyBearer: []
components:
  parameters:
    MyCardsIsOpen:
      name: isOpen
      in: query
      required: false
      schema:
        type: string
        enum:
          - 'true'
          - 'false'
          - all
        default: 'true'
      description: Open cards only (`true`), closed cards only (`false`), or both (`all`).
    MyCardsPageLimit:
      name: limit
      in: query
      required: false
      schema:
        type: integer
        minimum: 1
        maximum: 100
        default: 25
      description: Maximum cards returned.
    PageOffset:
      name: offset
      in: query
      required: false
      schema:
        type: integer
        minimum: 0
        default: 0
    MyCardsQuery:
      name: q
      in: query
      required: false
      schema:
        type: string
        maxLength: 200
      description: |
        Case-insensitive substring search across card name, description, and
        resolution, and the names of the card's project, placed teams, and their
        workflow statuses.
    MyCardsProjectId:
      name: projectId
      in: query
      required: false
      schema:
        type: string
        minLength: 1
        maxLength: 300
      description: Bare project id to match. Merged into `projectIds`.
    MyCardsProjectIds:
      name: projectIds
      in: query
      required: false
      schema:
        type: array
        items:
          type: string
          format: uuid
      style: form
      explode: true
      description: >-
        Match cards in any selected project. Also accepted as one
        comma-separated value.
    MyCardsTeamId:
      name: teamId
      in: query
      required: false
      schema:
        type: string
        minLength: 1
        maxLength: 255
      description: >
        Team id to match, merged into `teamIds`. The value `__none__` is a
        legacy

        alias for `includeNoTeam=true`; prefer `includeNoTeam`.
    CardTeamIds:
      name: teamIds
      in: query
      required: false
      schema:
        type: array
        maxItems: 50
        items:
          type: string
          format: uuid
      style: form
      explode: true
      description: Match cards placed on any selected linked team.
    CardStatusIds:
      name: statusIds
      in: query
      required: false
      schema:
        type: array
        maxItems: 50
        items:
          type: string
          format: uuid
      style: form
      explode: true
      description: Match cards whose selected-team placement uses any selected status.
    CardSprintIds:
      name: sprintIds
      in: query
      required: false
      schema:
        type: array
        maxItems: 50
        items:
          type: string
          format: uuid
      style: form
      explode: true
      description: Match cards whose team placement uses any selected sprint.
    MyCardsAssigneeId:
      name: assigneeId
      in: query
      required: false
      schema:
        type: string
        format: uuid
      description: Co-assignee user id to match. Merged into `assigneeIds`.
    CardAssigneeIds:
      name: assigneeIds
      in: query
      required: false
      schema:
        type: array
        maxItems: 50
        items:
          type: string
          format: uuid
      style: form
      explode: true
      description: Match cards assigned to any selected project member.
    CardTagIds:
      name: tagIds
      in: query
      required: false
      schema:
        type: array
        maxItems: 50
        items:
          type: string
          format: uuid
      style: form
      explode: true
      description: Match cards carrying any selected project tag.
    CardIncludeNoTeam:
      name: includeNoTeam
      in: query
      required: false
      schema:
        type: boolean
        default: false
      description: >-
        OR cards with no team placement into the team facet. This is not a
        sentinel team ID.
    CardDeadlineFrom:
      name: deadlineFrom
      in: query
      required: false
      schema:
        type: string
        format: date-time
      description: Inclusive ISO 8601 instant lower bound for non-null card deadlines.
    CardDeadlineTo:
      name: deadlineTo
      in: query
      required: false
      schema:
        type: string
        format: date-time
      description: Inclusive ISO 8601 instant upper bound for non-null card deadlines.
    CardIncludeNoDeadline:
      name: includeNoDeadline
      in: query
      required: false
      schema:
        type: boolean
        default: false
      description: >-
        OR cards with a null deadline into bounded deadline matches. With no
        deadline bounds, match only cards with no deadline.
    CardEffortMin:
      name: effortMin
      in: query
      required: false
      schema:
        type: integer
        minimum: 0
      description: Inclusive lower bound for non-null card effort.
    CardEffortMax:
      name: effortMax
      in: query
      required: false
      schema:
        type: integer
        minimum: 0
      description: Inclusive upper bound for non-null card effort.
    CardIncludeNoEffort:
      name: includeNoEffort
      in: query
      required: false
      schema:
        type: boolean
        default: false
      description: >-
        OR cards with null effort into bounded effort matches. With no effort
        bounds, match only cards with no effort.
    MyCardsSort:
      name: sort
      in: query
      required: false
      schema:
        type: string
        enum:
          - created_asc
          - created_desc
          - updated_asc
          - updated_desc
          - deadline_asc
          - deadline_desc
          - effort_asc
          - effort_desc
          - name_asc
          - name_desc
        default: deadline_asc
      description: |
        Stable card sort; card ID is the deterministic tie-breaker. Deadline and
        effort sorts place cards with no value last in both directions.
    MyCardsTimeZone:
      name: timeZone
      in: query
      required: false
      schema:
        type: string
        maxLength: 100
        example: America/Los_Angeles
      description: >
        IANA time zone of the caller, such as `America/Los_Angeles`. When
        present,

        `stats` counts days in this zone: today starts at local midnight, and
        the

        due-soon window ends at the last millisecond of the seventh local day
        after

        today, counted in calendar days so daylight-saving changes are
        respected.

        When omitted, the server's time zone is used. An unknown zone returns
        `400`.
  schemas:
    MyCardsResponse:
      type: object
      description: >-
        One page of the caller's assigned cards, with dashboard counters and
        facets.
      required:
        - cards
        - stats
        - filterOptions
        - meta
      properties:
        cards:
          type: array
          items:
            $ref: '#/components/schemas/MyCard'
        stats:
          $ref: '#/components/schemas/MyCardsStats'
        filterOptions:
          $ref: '#/components/schemas/MyCardsFilterOptions'
        meta:
          $ref: '#/components/schemas/MyCardsPageMeta'
      additionalProperties: false
    MyCard:
      type: object
      required:
        - id
        - name
        - projectId
        - projectName
        - deadline
        - effort
        - resolution
        - isOpen
        - authorDisplayName
        - createdAt
        - closedAt
        - updatedAt
        - assignees
        - teams
        - tags
      properties:
        id:
          type: string
          format: uuid
        name:
          type: string
          description: Card name, or `Untitled` when the card has none.
        projectId:
          type: string
          format: uuid
          description: Bare id of the project the card belongs to.
        projectName:
          type: string
        deadline:
          type:
            - string
            - 'null'
          format: date-time
        effort:
          type:
            - integer
            - 'null'
          minimum: 0
        resolution:
          type:
            - string
            - 'null'
        isOpen:
          type: boolean
        authorDisplayName:
          type:
            - string
            - 'null'
          description: Display name of the card's creator, or null when unknown.
        createdAt:
          type:
            - string
            - 'null'
          format: date-time
        closedAt:
          type:
            - string
            - 'null'
          format: date-time
          description: When the card was last closed. Always null for an open card.
        updatedAt:
          type:
            - string
            - 'null'
          format: date-time
        assignees:
          type: array
          items:
            $ref: '#/components/schemas/MyCardAssignee'
        teams:
          type: array
          description: The card's team board placements.
          items:
            $ref: '#/components/schemas/MyCardTeamPlacement'
        tags:
          type: array
          items:
            $ref: '#/components/schemas/MyCardTag'
      additionalProperties: false
    MyCardsStats:
      type: object
      description: >
        Counters over every open card assigned to the caller in a readable
        project,

        regardless of filters and `isOpen`. Day boundaries are local days in the

        request's `timeZone`, or in the server's time zone when it is omitted.
      required:
        - openCount
        - dueSoon7d
        - overdue
      properties:
        openCount:
          type: integer
          minimum: 0
        dueSoon7d:
          type: integer
          minimum: 0
          description: >-
            Open cards due between the start of today and the end of the seventh
            day from today.
        overdue:
          type: integer
          minimum: 0
          description: Open cards whose deadline is before the start of today.
      additionalProperties: false
    MyCardsFilterOptions:
      type: object
      required:
        - projects
        - teams
        - assignees
        - tags
        - statuses
        - sprints
      properties:
        projects:
          type: array
          items:
            $ref: '#/components/schemas/MyCardsFilterOption'
        teams:
          type: array
          items:
            $ref: '#/components/schemas/MyCardsFilterOption'
        assignees:
          type: array
          items:
            $ref: '#/components/schemas/MyCardsAssigneeFilterOption'
        tags:
          type: array
          items:
            $ref: '#/components/schemas/MyCardTag'
        statuses:
          type: array
          items:
            $ref: '#/components/schemas/MyCardsFilterOption'
        sprints:
          type: array
          items:
            $ref: '#/components/schemas/MyCardsFilterOption'
      additionalProperties: false
    MyCardsPageMeta:
      type: object
      required:
        - limit
        - total
        - pageStart
        - pageEnd
        - hasMore
        - previousOffset
        - nextOffset
      properties:
        limit:
          type: integer
          minimum: 1
          maximum: 100
        total:
          type: integer
          minimum: 0
          description: Cards matching every filter, across all pages.
        pageStart:
          type: integer
          minimum: 0
          description: >-
            One-based position of the first card on this page, or 0 when the
            page is empty.
        pageEnd:
          type: integer
          minimum: 0
          description: >-
            One-based position of the last card on this page, or `offset` when
            the page is empty.
        hasMore:
          type: boolean
        previousOffset:
          type:
            - integer
            - 'null'
          minimum: 0
        nextOffset:
          type:
            - integer
            - 'null'
          minimum: 0
      additionalProperties: false
    ErrorEnvelope:
      description: >
        The error shape for every failure on this API, whether it was refused by
        the

        credential layer before reaching a domain or by the domain itself.


        Branch on `code`, which is stable. `message` is for a person reading a
        log or

        a dialog and may be reworded. `details` carries fields specific to one

        failure — a project-limit refusal reports its numbers there — and is
        absent

        when there are none.
      type: object
      required:
        - success
        - error
      properties:
        success:
          type: boolean
          const: false
        error:
          type: object
          required:
            - code
            - message
          properties:
            code:
              type: string
            message:
              type: string
            details:
              type: object
              additionalProperties: true
          additionalProperties: true
      additionalProperties: true
    MyCardAssignee:
      type: object
      required:
        - id
        - displayName
      properties:
        id:
          type: string
          format: uuid
        displayName:
          type: string
          description: Empty when the user has no display name.
      additionalProperties: false
    MyCardTeamPlacement:
      type: object
      description: >
        A placement on a team board. `full` placements are on teams the caller
        can

        read and also carry `organizationId`; `summary` placements omit it.
      required:
        - id
        - name
        - statusId
        - statusName
        - statusColor
        - sprintId
        - sprintName
        - placementAccess
      properties:
        id:
          type: string
          format: uuid
        name:
          type: string
        statusId:
          type:
            - string
            - 'null'
          format: uuid
        statusName:
          type:
            - string
            - 'null'
        statusColor:
          type:
            - string
            - 'null'
          description: >-
            Hex color of the workflow status, the same value project card search
            returns as `status_color`.
        sprintId:
          type:
            - string
            - 'null'
          format: uuid
        sprintName:
          type:
            - string
            - 'null'
        placementAccess:
          type: string
          enum:
            - full
            - summary
        organizationId:
          type:
            - string
            - 'null'
          format: uuid
          description: Present only when `placementAccess` is `full`.
      additionalProperties: false
    MyCardTag:
      type: object
      required:
        - id
        - name
        - color
      properties:
        id:
          type: string
          format: uuid
        name:
          type: string
        color:
          type: string
      additionalProperties: false
    MyCardsFilterOption:
      type: object
      required:
        - id
        - name
      properties:
        id:
          type: string
          format: uuid
        name:
          type: string
      additionalProperties: false
    MyCardsAssigneeFilterOption:
      type: object
      required:
        - id
        - displayName
      properties:
        id:
          type: string
          format: uuid
        displayName:
          type:
            - string
            - 'null'
      additionalProperties: false
  responses:
    BadRequest:
      description: |
        Malformed request parameters or body. Agile requests may return
        `INVALID_PAGINATION` or `INVALID_IDEMPOTENCY_KEY`.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorEnvelope'
    Unauthorized:
      description: >
        No credential was supplied, or the supplied credential is malformed,
        expired,

        or revoked. A credential that is present but unusable is never
        downgraded to

        an anonymous request.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorEnvelope'
    Forbidden:
      description: >
        Authenticated but not authorized. Either the acting user lacks the
        required

        resource permission, the key's scope ceiling excludes it, or the
        endpoint

        rejects this credential type (`CREDENTIAL_NOT_PERMITTED`).
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorEnvelope'
    RateLimited:
      description: Request rate exceeded, either globally or for this key.
      headers:
        Retry-After:
          schema:
            type: integer
            minimum: 1
          description: Seconds to wait before retrying.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorEnvelope'
    InternalError:
      description: Unexpected server error.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorEnvelope'
  securitySchemes:
    ApiKeyBearer:
      type: http
      scheme: bearer
      bearerFormat: dav_ak_live_... or dav_ak_test_...
      x-default: dav_ak_live_your_token
      description: >
        Personal access token. The scopes granted at issuance determine both
        which

        operations the key may call and the ceiling on the resource permissions
        it

        can exercise. Each scope family is a ladder: `projects:manage` implies

        `projects:write` and `projects:read`; `cards:manage` implies
        `cards:write`

        and `cards:read`; and `teams:manage` implies `teams:write` and
        `teams:read`.

        These are named API capability bundles, not blanket domain roles:

        `manage` exposes only the permissions enumerated for that scope and
        never

        bypasses the acting user's current role-based access.

````

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