Grafana

opencollection: 1.0.0
info:
  name: Grafana
  version: 0.0.1
request:
  auth:
    type: basic
    username: '{{username}}'
    password: '{{password}}'
items:
- info:
    name: Data
    type: folder
  items:
  - info:
      name: Grafana Get Data Sources
      type: http
    http:
      method: GET
      url: http://{defaultHost}/datasources
    docs: The GET /datasources endpoint in the Grafana HTTP API retrieves a list of all configured data sources within the
      Grafana instance. This operation returns an array of data source objects, each containing details such as the data source
      ID, name, type (like Prometheus, InfluxDB, or Elasticsearch), URL, access method, and other configuration parameters.
      Authentication is required to access this endpoint, and the response will only include data sources that the authenticated
      user has permission to v
  - info:
      name: Grafana Get Data Source Id By Name
      type: http
    http:
      method: GET
      url: http://{defaultHost}/datasources/id/:name
      params:
      - name: name
        value: ''
        type: path
    docs: This API operation retrieves the unique identifier of a Grafana data source by providing its name as a path parameter.
      It performs a GET request to the endpoint '/datasources/id/{name}' where {name} is replaced with the actual name of
      the data source you want to look up. The operation returns the numeric ID associated with that specific data source,
      which can be useful for subsequent API calls that require the data source ID rather than its name. This is particularly
      helpful when you need to pro
  - info:
      name: Grafana Get Data Source By Name
      type: http
    http:
      method: GET
      url: http://{defaultHost}/datasources/name/:name
      params:
      - name: name
        value: ''
        type: path
    docs: This API operation retrieves a specific data source configuration from Grafana by using its unique name as an identifier.
      When you send a GET request to the endpoint with the data source name as a path parameter, Grafana returns the complete
      configuration details of that data source, including its type, connection settings, authentication credentials, and
      other relevant metadata. This is particularly useful when you need to programmatically access or verify the configuration
      of a specific data s
  - info:
      name: Grafana Delete Data Source By Name
      type: http
    http:
      method: DELETE
      url: http://{defaultHost}/datasources/name/:name
      params:
      - name: name
        value: ''
        type: path
    docs: 'Removes a data source from Grafana by specifying its unique name rather than its numeric ID. This operation permanently
      deletes the data source configuration including all associated settings, credentials, and metadata. Once deleted, any
      dashboards or panels that reference this data source will no longer function properly until reconfigured with an alternative
      data source. This endpoint is particularly useful when automating data source management through scripts or infrastructure-as-code
      tools '
  - info:
      name: Grafana Get Data Source By UID
      type: http
    http:
      method: GET
      url: http://{defaultHost}/datasources/uid/:uid
      params:
      - name: uid
        value: ''
        type: path
    docs: This API operation retrieves detailed information about a specific data source in Grafana by providing its unique
      identifier (UID). When called with a GET request to the endpoint /datasources/uid/{uid}, it returns the complete configuration
      and metadata for the requested data source, including its name, type, access method, connection details, and other relevant
      settings. This endpoint is particularly useful when you need to programmatically query or verify the configuration of
      a specific data s
  - info:
      name: Grafana Update Data Source By UID
      type: http
    http:
      method: PUT
      url: http://{defaultHost}/datasources/uid/:uid
      params:
      - name: uid
        value: ''
        type: path
      body:
        type: json
        data: '{}'
    docs: This API operation updates an existing data source in Grafana by specifying its unique identifier (UID) in the URL
      path. The PUT request allows administrators to modify the configuration of a data source, including its name, type,
      URL, authentication settings, and other connection parameters. The operation requires the data source's UID as a path
      parameter and accepts a JSON payload containing the updated data source configuration in the request body. Upon successful
      execution, it returns the up
  - info:
      name: Grafana Delete Data Source By UID
      type: http
    http:
      method: DELETE
      url: http://{defaultHost}/datasources/uid/:uid
      params:
      - name: uid
        value: ''
        type: path
    docs: Deletes a data source from Grafana by its unique identifier (UID). This operation permanently removes the specified
      data source configuration from the Grafana instance, including all its settings and connection details. The UID parameter
      in the URL path identifies which data source to delete. This is a destructive action that cannot be undone, and any
      dashboards or panels relying on this data source will lose their connection to it. Proper permissions are required to
      execute this operation, typi
  - info:
      name: Grafana Get Data Source By ID
      type: http
    http:
      method: GET
      url: http://{defaultHost}/datasources/:id
      params:
      - name: id
        value: ''
        type: path
    docs: Retrieves detailed information about a specific data source in Grafana by providing its unique identifier. This
      endpoint returns comprehensive configuration details for the data source including its name, type, URL, access mode,
      authentication settings, and other metadata associated with the specified ID. It requires appropriate permissions to
      view data source configurations and is commonly used when you need to inspect or verify the settings of a particular
      data source that has already been con
  - info:
      name: Grafana Update Data Source By ID
      type: http
    http:
      method: PUT
      url: http://{defaultHost}/datasources/:id
      params:
      - name: id
        value: ''
        type: path
      body:
        type: json
        data: '{}'
    docs: Updates an existing data source in Grafana by specifying its unique identifier in the URL path. This PUT operation
      requires the complete data source configuration including connection details, authentication credentials, and any custom
      settings. The request must include all data source properties as the PUT method typically replaces the entire resource
      rather than partially updating it. Users need appropriate permissions to modify data sources, and the operation returns
      the updated data source c
  - info:
      name: Grafana Delete Data Source By ID
      type: http
    http:
      method: DELETE
      url: http://{defaultHost}/datasources/:id
      params:
      - name: id
        value: ''
        type: path
    docs: This API operation removes a specific data source from Grafana by referencing its unique identifier. When executed,
      it performs a DELETE request to the endpoint /datasources/{id}, where {id} represents the numeric identifier of the
      data source to be removed. The operation permanently deletes the data source configuration from Grafana, including all
      its associated settings and connection details. This action requires appropriate administrative permissions and cannot
      be undone once completed. Upon
- info:
    name: Add
    type: folder
  items:
  - info:
      name: Grafana Add Data Source
      type: http
    http:
      method: POST
      url: http://{defaultHost}/datasources
      body:
        type: json
        data: '{}'
    docs: Adds a new data source to Grafana by creating a configuration that defines how Grafana connects to and retrieves
      data from external systems such as Prometheus, Elasticsearch, MySQL, or other supported data sources. This POST operation
      requires authentication and accepts a JSON payload containing the data source properties including the type, name, access
      mode (proxy or direct), URL, database credentials if applicable, and any additional JSON data specific to the data source
      type. Upon successful
  - info:
      name: Grafana Add Org User
      type: http
    http:
      method: POST
      url: http://{defaultHost}/orgs/:org_id/users
      params:
      - name: org_id
        value: ''
        type: path
      body:
        type: json
        data: '{}'
    docs: Adds a new user to an existing organization in Grafana by sending a POST request to the /orgs/{org_id}/users endpoint,
      where {org_id} is the unique identifier of the target organization. This operation requires authentication and appropriate
      permissions to manage organization membership. The request body typically includes the user's login credentials or user
      ID along with the desired role (such as Viewer, Editor, or Admin) that determines their access level within the organization.
      Upon success
  - info:
      name: Grafana Add Org Invite
      type: http
    http:
      method: POST
      url: http://{defaultHost}/org/invites
      body:
        type: json
        data: '{}'
    docs: This API operation allows you to create and send an invitation for a user to join a specific organization in Grafana.
      By making a POST request to the /org/invites endpoint, administrators can invite new members by providing details such
      as the invitee's email address, username, and the role they should have within the organization. The invitation generates
      a unique token that is sent to the specified user, allowing them to accept the invitation and gain access to the organization
      with the assign
  - info:
      name: Grafana Add Org User To Current Org
      type: http
    http:
      method: POST
      url: http://{defaultHost}/org/users
      body:
        type: json
        data: '{}'
    docs: This API operation allows administrators to add a new user to the current organization in Grafana by sending a POST
      request to the /org/users endpoint. When invoked, it creates a new membership association between a specified user and
      the organization that the authenticated user currently belongs to. The request typically requires parameters such as
      the user's login credentials or user ID, along with the desired role (Viewer, Editor, or Admin) that the new member
      should have within the organizat
  - info:
      name: Grafana Add Team Member
      type: http
    http:
      method: POST
      url: http://{defaultHost}/teams/:team_id/members
      params:
      - name: team_id
        value: ''
        type: path
      body:
        type: json
        data: '{}'
    docs: This API operation adds a new member to a specific team in Grafana by making a POST request to the /teams/{team_id}/members
      endpoint, where {team_id} is the unique identifier of the team. The operation allows administrators or users with appropriate
      permissions to expand team membership by associating additional users with an existing team, typically requiring the
      user ID or username to be specified in the request body to identify which user should be added to the team.
  - info:
      name: Grafana Add Team Role
      type: http
    http:
      method: POST
      url: http://{defaultHost}/access-control/teams/:teamId/roles
      params:
      - name: teamId
        value: ''
        type: path
      body:
        type: json
        data: '{}'
    docs: This API operation adds a role to a specific team in Grafana's access control system. It uses a POST request to
      the endpoint /access-control/teams/{teamId}/roles, where {teamId} is the unique identifier of the team receiving the
      new role assignment. The operation allows administrators to grant specific permissions and access levels to an entire
      team by associating a role with that team, streamlining permission management across multiple users who belong to the
      same team.
  - info:
      name: Grafana Add User Role
      type: http
    http:
      method: POST
      url: http://{defaultHost}/access-control/users/:userId/roles
      params:
      - name: userId
        value: ''
        type: path
      body:
        type: json
        data: '{}'
    docs: This API operation adds a role to a specific user in Grafana's access control system by sending a POST request to
      the endpoint /access-control/users/{userId}/roles, where {userId} is replaced with the target user's identifier. The
      operation allows administrators to grant additional permissions and access rights to users by assigning them predefined
      or custom roles within the Grafana instance. This is typically used for managing user permissions and implementing role-based
      access control (RBAC) t
  - info:
      name: Grafana Add Team Group Api
      type: http
    http:
      method: POST
      url: http://{defaultHost}/teams/:teamId/groups
      params:
      - name: teamId
        value: ''
        type: path
      body:
        type: json
        data: '{}'
    docs: The Add Team Group API is a POST operation available at the endpoint /teams/{teamId}/groups in Grafana that allows
      administrators to associate an external authentication group with a specific Grafana team. This operation requires the
      teamId parameter in the URL path to identify the target team, and typically accepts a request body containing details
      about the group to be added, such as the group identifier from the external authentication provider (like LDAP, OAuth,
      or SAML). When executed succe
- info:
    name: Correlations
    type: folder
  items:
  - info:
      name: Grafana Get Correlations
      type: http
    http:
      method: GET
      url: http://{defaultHost}/datasources/correlations
      params:
      - name: limit
        value: ''
        type: query
        description: Limit the maximum number of correlations to return per page
      - name: page
        value: ''
        type: query
        description: Page index for starting fetching correlations
      - name: sourceUID
        value: ''
        type: query
        description: Source datasource UID filter to be applied to correlations
    docs: This API operation retrieves correlation configurations from Grafana datasources. Correlations define relationships
      between different data sources, allowing users to create links and navigate between related data across multiple datasources.
      The GET request to the /datasources/correlations endpoint returns a list of all configured correlations in the Grafana
      instance, including details such as source and target datasources, correlation labels, and transformation rules that
      enable cross-datasourc
  - info:
      name: Grafana Get Correlations By Source UID
      type: http
    http:
      method: GET
      url: http://{defaultHost}/datasources/uid/:sourceUID/correlations
      params:
      - name: sourceUID
        value: ''
        type: path
    docs: 'This API operation retrieves all correlations associated with a specific data source in Grafana by providing the
      data source''s unique identifier (UID). It uses a GET request to the endpoint /datasources/uid/{sourceUID}/correlations,
      where {sourceUID} is replaced with the actual UID of the data source you want to query. The operation returns a list
      of correlation configurations that have been defined for the specified data source, which are used to link related data
      across different data sources '
- info:
    name: Calls
    type: folder
  items:
  - info:
      name: Grafana Datasource Proxy GET By UID Calls
      type: http
    http:
      method: GET
      url: http://{defaultHost}/datasources/proxy/uid/:uid/:datasource_proxy_route
      params:
      - name: datasource_proxy_route
        value: ''
        type: path
      - name: uid
        value: ''
        type: path
    docs: This API operation performs a GET request to proxy datasource calls through Grafana using a datasource's unique
      identifier (UID). It forwards requests to the configured datasource via the specified proxy route, allowing Grafana
      to act as an intermediary between the client and the actual datasource. The operation uses the path pattern '/datasources/proxy/uid/{uid}/{datasource_proxy_route}'
      where {uid} identifies the specific datasource and {datasource_proxy_route} represents the downstream API pa
  - info:
      name: Grafana Datasource Proxy POST By UID Calls
      type: http
    http:
      method: POST
      url: http://{defaultHost}/datasources/proxy/uid/:uid/:datasource_proxy_route
      params:
      - name: datasource_proxy_route
        value: ''
        type: path
      - name: uid
        value: ''
        type: path
    docs: This API operation enables POST requests to be proxied through Grafana to a configured datasource identified by
      its unique identifier (UID). The endpoint acts as an intermediary, forwarding requests from the Grafana UI to the target
      datasource using the specified proxy route path. This allows Grafana to securely communicate with various datasources
      without exposing their direct endpoints to clients, while maintaining authentication and authorization controls. The
      datasource_proxy_route parameter
  - info:
      name: Grafana Datasource Proxy DELETE By UID Calls
      type: http
    http:
      method: DELETE
      url: http://{defaultHost}/datasources/proxy/uid/:uid/:datasource_proxy_route
      params:
      - name: uid
        value: ''
        type: path
      - name: datasource_proxy_route
        value: ''
        type: path
    docs: This API operation performs a DELETE request to a Grafana datasource through the proxy endpoint, utilizing the datasource's
      unique identifier (UID) and a specific proxy route. It allows clients to make DELETE operations against the underlying
      datasource via Grafana's proxy layer, which handles authentication, authorization, and request routing. The operation
      is typically invoked by Grafana's user interface to delete resources or data from configured datasources without direct
      client access to th
  - info:
      name: Grafana Datasource Proxy GET calls
      type: http
    http:
      method: GET
      url: http://{defaultHost}/datasources/proxy/:id/:datasource_proxy_route
      params:
      - name: datasource_proxy_route
        value: ''
        type: path
      - name: id
        value: ''
        type: path
    docs: This API operation provides a proxy endpoint for executing GET requests against a configured datasource in Grafana.
      By specifying the datasource ID and a custom proxy route, it allows Grafana to forward requests to the underlying data
      source while handling authentication, CORS, and other middleware concerns transparently. This is particularly useful
      for querying data sources that may have complex authentication requirements or need to be accessed from the browser
      without exposing credentials, as
  - info:
      name: Grafana Datasource Proxy POST Calls
      type: http
    http:
      method: POST
      url: http://{defaultHost}/datasources/proxy/:id/:datasource_proxy_route
      params:
      - name: datasource_proxy_route
        value: ''
        type: path
      - name: id
        value: ''
        type: path
    docs: The Grafana datasource proxy POST operation allows users to send POST requests to a configured datasource through
      Grafana's proxy endpoint by specifying the datasource ID and the target route. This API call acts as an intermediary
      that forwards HTTP POST requests to the underlying datasource while handling authentication, connection management,
      and security concerns on behalf of the client. The endpoint accepts a datasource identifier in the path along with a
      dynamic route parameter that determi
- info:
    name: Data Sources
    type: folder
  items:
  - info:
      name: Grafana Datasource Proxy DELET Ecalls
      type: http
    http:
      method: DELETE
      url: http://{defaultHost}/datasources/proxy/:id/:datasource_proxy_route
      params:
      - name: id
        value: ''
        type: path
      - name: datasource_proxy_route
        value: ''
        type: path
    docs: The Datasource Proxy DELETE operation in Grafana allows users to send HTTP DELETE requests to a configured datasource
      through Grafana's proxy endpoint by specifying the datasource ID and the target route path. This API endpoint follows
      the pattern /datasources/proxy/{id}/{datasource_proxy_route} where {id} represents the unique identifier of the datasource
      and {datasource_proxy_route} is the specific path on the target datasource that should receive the DELETE request. This
      proxying mechanism en
- info:
    name: Correlation
    type: folder
  items:
  - info:
      name: Grafana Create Correlation
      type: http
    http:
      method: POST
      url: http://{defaultHost}/datasources/uid/:sourceUID/correlations
      params:
      - name: sourceUID
        value: ''
        type: path
      body:
        type: json
        data: '{}'
    docs: Creates a new correlation in Grafana between two data sources, allowing users to establish relationships and navigate
      between different data sources using the specified source data source UID. This operation enables the creation of links
      that help connect related data across different monitoring or logging systems, facilitating easier investigation and
      analysis workflows by defining how data in one source relates to data in another source through correlation configurations.
  - info:
      name: Grafana Get Correlation
      type: http
    http:
      method: GET
      url: http://{defaultHost}/datasources/uid/:sourceUID/correlations/:correlationUID
      params:
      - name: sourceUID
        value: ''
        type: path
      - name: correlationUID
        value: ''
        type: path
    docs: 'The Get Correlation API operation in Grafana retrieves a specific correlation configuration between data sources
      using their unique identifiers. By making a GET request to the endpoint `/datasources/uid/{sourceUID}/correlations/{correlationUID}`,
      users can fetch detailed information about an existing correlation, including its configuration settings, transformations,
      and the relationship between a source data source and a target data source. This operation requires both the unique
      identifier of '
  - info:
      name: Grafana Update Correlation
      type: http
    http:
      method: PATCH
      url: http://{defaultHost}/datasources/uid/:sourceUID/correlations/:correlationUID
      params:
      - name: sourceUID
        value: ''
        type: path
      - name: correlationUID
        value: ''
        type: path
      body:
        type: json
        data: '{}'
    docs: Updates an existing correlation identified by its UID within a specific data source, also identified by UID. This
      PATCH operation allows you to modify the properties of a correlation, which defines relationships between queries or
      data across different data sources in Grafana. The correlation UID and source data source UID must be provided in the
      path parameters to target the specific correlation to update. The request typically includes fields such as the target
      data source, transformation expr
  - info:
      name: Grafana Delete Correlation
      type: http
    http:
      method: DELETE
      url: http://{defaultHost}/datasources/uid/:uid/correlations/:correlationUID
      params:
      - name: uid
        value: ''
        type: path
      - name: correlationUID
        value: ''
        type: path
    docs: 'This API operation deletes a specific correlation in Grafana by targeting both the data source and correlation
      identifiers. The endpoint requires two parameters: the UID of the data source that owns the correlation and the correlationUID
      which uniquely identifies the correlation to be removed. When executed with a DELETE HTTP method, it permanently removes
      the specified correlation configuration that links queries or data between different data sources, helping administrators
      clean up unused or '
- info:
    name: Checks
    type: folder
  items:
  - info:
      name: Grafana Check Datasource Health With UID
      type: http
    http:
      method: GET
      url: http://{defaultHost}/datasources/uid/:uid/health
      params:
      - name: uid
        value: ''
        type: path
    docs: 'This API operation performs a health check on a specific Grafana datasource identified by its unique identifier
      (UID). When invoked via a GET request to the endpoint ''/datasources/uid/{uid}/health'', it verifies the connectivity
      and operational status of the datasource, returning information about whether the datasource is accessible and functioning
      correctly. This is useful for monitoring and troubleshooting datasource configurations, allowing administrators to quickly
      determine if a particular '
  - info:
      name: Grafana Check Datasource Health By ID
      type: http
    http:
      method: GET
      url: http://{defaultHost}/datasources/:id/health
      params:
      - name: id
        value: ''
        type: path
    docs: Sends a health check request to the data source identified by its numeric ID and returns the current operational
      status. This endpoint verifies whether Grafana can successfully connect to and communicate with the specified data source,
      helping administrators diagnose connectivity issues or validate data source configurations. The response typically includes
      status information indicating whether the data source is reachable and functioning properly, along with any relevant
      error messages if the h
- info:
    name: Call
    type: folder
  items:
  - info:
      name: Grafana Call Datasource Resource With UID
      type: http
    http:
      method: GET
      url: http://{defaultHost}/datasources/uid/:uid/resources/:datasource_proxy_route
      params:
      - name: datasource_proxy_route
        value: ''
        type: path
      - name: uid
        value: ''
        type: path
    docs: This API operation enables clients to interact with a specific datasource in Grafana by making GET requests to custom
      resource endpoints exposed by that datasource. It uses the datasource's unique identifier (UID) rather than its numeric
      ID to route requests through Grafana's proxy to the underlying datasource's resource paths. The operation accepts a
      variable datasource_proxy_route parameter that allows accessing different resource endpoints specific to the datasource
      type, effectively acting a
  - info:
      name: Grafana Call Datasource Resource By ID
      type: http
    http:
      method: GET
      url: http://{defaultHost}/datasources/:id/resources/:datasource_proxy_route
      params:
      - name: datasource_proxy_route
        value: ''
        type: path
      - name: id
        value: ''
        type: path
    docs: This API operation allows you to make GET requests to a specific Grafana datasource's custom resources by providing
      the datasource ID and a resource route path. It acts as a proxy that forwards requests to the underlying datasource
      plugin's resource handler, enabling access to datasource-specific endpoints and functionality that may not be covered
      by standard Grafana APIs. The datasource_proxy_route parameter is a wildcard path that gets passed through to the datasource's
      backend, allowing flexi
- info:
    name: Metrics
    type: folder
  items:
  - info:
      name: Grafana Query Metrics With Expressions
      type: http
    http:
      method: POST
      url: http://{defaultHost}/ds/query
      body:
        type: json
        data: '{}'
    docs: This API operation enables querying of metrics data in Grafana using the datasource query endpoint, supporting advanced
      query expressions and transformations. It accepts POST requests at the /ds/query endpoint and allows users to execute
      complex queries against configured data sources, combining multiple queries with mathematical expressions, statistical
      functions, and data transformations to derive meaningful insights from time-series data. The operation supports various
      datasource types and re
- info:
    name: Folders
    type: folder
  items:
  - info:
      name: Grafana Get Folders
      type: http
    http:
      method: GET
      url: http://{defaultHost}/folders
      params:
      - name: limit
        value: ''
        type: query
        description: Limit the maximum number of folders to return
      - name: page
        value: ''
        type: query
        description: Page index for starting fetching folders
      - name: parentUid
        value: ''
        type: query
        description: The parent folder UID
      - name: permission
        value: ''
        type: query
        description: Set to `Edit` to return folders that the user can edit
    docs: Retrieves a list of all folders in the Grafana instance. This endpoint returns folder metadata including folder
      ID, UID, title, and URL, allowing users to navigate and organize dashboards hierarchically. The operation supports optional
      query parameters to filter results by limit and page for pagination. Authentication is required and the response includes
      an array of folder objects that can be used to manage dashboard organization and access control within Grafana.
  - info:
      name: Grafana Get Folder By ID
      type: http
    http:
      method: GET
      url: http://{defaultHost}/folders/id/:folder_id
      params:
      - name: folder_id
        value: ''
        type: path
    docs: 'The GET /folders/id/{folder_id} endpoint in Grafana retrieves detailed information about a specific folder using
      its unique identifier. This operation allows users to fetch folder metadata including its title, UID, permissions, and
      other configuration details by providing the numeric folder ID in the path parameter. It''s particularly useful when
      you need to access folder information programmatically and have the folder''s ID rather than its UID, returning a JSON
      response with the complete folder '
  - info:
      name: Grafana Get Folder By UID
      type: http
    http:
      method: GET
      url: http://{defaultHost}/folders/:folder_uid
      params:
      - name: folder_uid
        value: ''
        type: path
    docs: This API operation retrieves detailed information about a specific Grafana folder by providing its unique identifier
      (UID). By making a GET request to the endpoint with the folder's UID as a path parameter, users can fetch metadata about
      the folder including its title, UID, ID, URL, version, and other configuration details. This is useful for programmatically
      accessing folder properties, verifying folder existence, or gathering information needed for subsequent operations such
      as dashboard manag
  - info:
      name: Grafana Update Folder
      type: http
    http:
      method: PUT
      url: http://{defaultHost}/folders/:folder_uid
      params:
      - name: folder_uid
        value: ''
        type: path
      body:
        type: json
        data: '{}'
    docs: Updates an existing folder in Grafana identified by its unique folder UID. This PUT operation allows you to modify
      folder properties such as the folder's title, and optionally update the folder's version for optimistic concurrency
      control. The request requires authentication and appropriate permissions to modify the specified folder. Upon successful
      execution, it returns the updated folder object with its current metadata including the new title, UID, ID, URL, and
      updated version number. This op
  - info:
      name: Grafana Move Folder
      type: http
    http:
      method: POST
      url: http://{defaultHost}/folders/:folder_uid/move
      params:
      - name: folder_uid
        value: ''
        type: path
      body:
        type: json
        data: '{}'
    docs: This API operation moves a Grafana folder identified by its unique identifier (folder_uid) to a new location within

# --- truncated at 32 KB (272 KB total) ---
# Full source: https://raw.githubusercontent.com/api-evangelist/grafana/refs/heads/main/apis.yml