## Delete Evaluation Dashboard

`client.EvaluationDashboards.Archive(ctx, dashboardID) (*EvaluationDashboard, error)`

**delete** `/v5/evaluation-dashboards/{dashboard_id}`

Soft-delete a dashboard by setting its archived timestamp.

The dashboard row is retained and marked archived rather than physically removed, so
it stops appearing in default listings but can still be fetched with
`include_archived=true`; the archived dashboard is returned by this call. Associated
widgets and widget results are not deleted or detached. Returns a not-found error if
the dashboard does not exist in the caller's account.

### Parameters

- `dashboardID string`

### Returns

- `type EvaluationDashboard struct{…}`

  - `ID string`

    Unique identifier of the dashboard

  - `AccountID string`

    Account that owns this dashboard

  - `CreatedAt Time`

    When the dashboard was created

  - `CreatedBy Identity`

    The identity that created the entity.

    - `ID string`

    - `Type IdentityType`

      - `const IdentityTypeUser IdentityType = "user"`

      - `const IdentityTypeServiceAccount IdentityType = "service_account"`

    - `Object IdentityObject`

      - `const IdentityObjectIdentity IdentityObject = "identity"`

  - `Name string`

    Dashboard name

  - `Tags []string`

    The tags associated with the entity

  - `UpdatedAt Time`

    When the dashboard was last updated

  - `ArchivedAt Time`

    When the dashboard was archived (soft-deleted)

  - `Description string`

    Dashboard description

  - `ErrorMessage string`

    Error message if computation failed

  - `EvaluationGroupID string`

    Evaluation group ID

  - `EvaluationID string`

    Evaluation ID

  - `Object EvaluationDashboardObject`

    - `const EvaluationDashboardObjectEvaluationDashboard EvaluationDashboardObject = "evaluation_dashboard"`

  - `WidgetOrder []string`

    Ordered array of widget IDs

  - `WidgetResults []EvaluationDashboardWidgetResult`

    Widget results for this dashboard. Populated with 'widget_results' view.

    - `ID string`

      Unique identifier of the widget result

    - `AccountID string`

      Account that owns this widget result

    - `ComputationStatus EvaluationDashboardWidgetResultComputationStatus`

      Status of the computation

      - `const EvaluationDashboardWidgetResultComputationStatusPending EvaluationDashboardWidgetResultComputationStatus = "pending"`

      - `const EvaluationDashboardWidgetResultComputationStatusCompleted EvaluationDashboardWidgetResultComputationStatus = "completed"`

      - `const EvaluationDashboardWidgetResultComputationStatusFailed EvaluationDashboardWidgetResultComputationStatus = "failed"`

    - `CreatedAt Time`

      When the widget result was created

    - `WidgetID string`

      Unique identifier of the widget

    - `ComputationJobID string`

      Temporal workflow ID or job ID for async computation tracking

    - `ComputedAt Time`

      Timestamp when computation completed successfully

    - `ComputedResult map[string, any]`

      Cached computation results

    - `ErrorMessage string`

      Error message if computation failed

    - `EvaluationGroupID string`

      FK to evaluation_groups. Null if result is for a single evaluation.

    - `EvaluationID string`

      FK to evaluations. Null if result is for an evaluation group.

    - `Object EvaluationDashboardWidgetResultObject`

      - `const EvaluationDashboardWidgetResultObjectEvaluationDashboardWidgetResult EvaluationDashboardWidgetResultObject = "evaluation_dashboard_widget_result"`

    - `Widget EvaluationDashboardWidget`

      Widget that this result is for

      - `ID string`

        Unique identifier of the widget

      - `AccountID string`

        Account that owns this widget

      - `CreatedAt Time`

        When the widget was created

      - `Title string`

        Widget title

      - `Type EvaluationWidgetTypeEnum`

        Widget type

        - `const EvaluationWidgetTypeEnumBar EvaluationWidgetTypeEnum = "bar"`

        - `const EvaluationWidgetTypeEnumHistogram EvaluationWidgetTypeEnum = "histogram"`

        - `const EvaluationWidgetTypeEnumDonut EvaluationWidgetTypeEnum = "donut"`

        - `const EvaluationWidgetTypeEnumScatter EvaluationWidgetTypeEnum = "scatter"`

        - `const EvaluationWidgetTypeEnumMetric EvaluationWidgetTypeEnum = "metric"`

        - `const EvaluationWidgetTypeEnumTable EvaluationWidgetTypeEnum = "table"`

        - `const EvaluationWidgetTypeEnumMarkdown EvaluationWidgetTypeEnum = "markdown"`

        - `const EvaluationWidgetTypeEnumHeading EvaluationWidgetTypeEnum = "heading"`

        - `const EvaluationWidgetTypeEnumTimeseries EvaluationWidgetTypeEnum = "timeseries"`

      - `ArchivedAt Time`

        When the widget was archived (soft-deleted)

      - `Config map[string, any]`

        Chart-specific display configuration

      - `Object EvaluationDashboardWidgetObject`

        - `const EvaluationDashboardWidgetObjectEvaluationDashboardWidget EvaluationDashboardWidgetObject = "evaluation_dashboard_widget"`

      - `Query EvaluationDashboardWidgetQueryUnion`

        Structured query AST for metric computation (SeriesQuery or MetricQuery)

        - `type SeriesQuery struct{…}`

          Query that returns a series of records (used for table/bar/histogram/donut/scatter widgets).

          Used for widget types: table, bar, histogram, donut, scatter.
          Returns: {"type": "series", "data": [...]}

          Example SQL equivalent:
          SELECT category, AVG(score) as avg_score, COUNT(*) as count
          FROM evaluation_items
          WHERE score > 0.5 AND category = 'test'
          GROUP BY category
          ORDER BY avg_score DESC
          LIMIT 100

          - `Select []SelectItem`

            - `Expression SelectItemExpressionUnion`

              Reference to a column from evaluation_items.data

              Example:
              {"type": "COLUMN", "column": "category"}

              - `type SelectItemExpressionColumn struct{…}`

                Reference to a column from evaluation_items.data

                Example:
                {"type": "COLUMN", "column": "category"}

                - `Column string`

                  Column name from evaluation_items.data

                - `Source string`

                  Column source: 'data' or 'task_result_cache'

                - `Type string`

                  - `const SelectItemExpressionColumnTypeColumn SelectItemExpressionColumnType = "COLUMN"`

              - `type SelectItemExpressionAggregation struct{…}`

                Aggregation function to apply

                Examples:
                {"type": "AGGREGATION", "function": "AVG", "column": "score"}
                {"type": "AGGREGATION", "function": "COUNT", "column": "*"}
                {"type": "AGGREGATION", "function": "PERCENTILE", "column": "score", "params": {"percentile": 95}}

                - `Column string`

                  Column to aggregate, or '*' for COUNT(*)

                - `Function string`

                  Supported aggregation functions

                  - `const SelectItemExpressionAggregationFunctionCount SelectItemExpressionAggregationFunction = "COUNT"`

                  - `const SelectItemExpressionAggregationFunctionSum SelectItemExpressionAggregationFunction = "SUM"`

                  - `const SelectItemExpressionAggregationFunctionAvg SelectItemExpressionAggregationFunction = "AVG"`

                  - `const SelectItemExpressionAggregationFunctionMin SelectItemExpressionAggregationFunction = "MIN"`

                  - `const SelectItemExpressionAggregationFunctionMax SelectItemExpressionAggregationFunction = "MAX"`

                  - `const SelectItemExpressionAggregationFunctionStddev SelectItemExpressionAggregationFunction = "STDDEV"`

                  - `const SelectItemExpressionAggregationFunctionVariance SelectItemExpressionAggregationFunction = "VARIANCE"`

                  - `const SelectItemExpressionAggregationFunctionPercentile SelectItemExpressionAggregationFunction = "PERCENTILE"`

                  - `const SelectItemExpressionAggregationFunctionCountDistinct SelectItemExpressionAggregationFunction = "COUNT_DISTINCT"`

                  - `const SelectItemExpressionAggregationFunctionPercentage SelectItemExpressionAggregationFunction = "PERCENTAGE"`

                - `EvaluationIDs []string`

                  Optional subset of evaluation IDs for per-aggregation filtering in evaluation group dashboards.

                - `Params map[string, any]`

                  Function parameters (e.g., {'percentile': 95} for PERCENTILE, {'percentage_filters': Filter} for PERCENTAGE)

                - `Source string`

                  Column source: 'data' or 'task_result_cache'

                - `Type string`

                  - `const SelectItemExpressionAggregationTypeAggregation SelectItemExpressionAggregationType = "AGGREGATION"`

            - `Alias string`

              Optional alias for the selected item

          - `EvaluationIDs []string`

            Optional subset of evaluation IDs to compute on. Only applicable for evaluation group dashboards. If omitted, computes on all evaluations in the group.

          - `Filter Filter`

            Filter conditions (WHERE clause)

            - `Conditions []FilterCondition`

              - `Column string`

                Column name to filter on

              - `Operator string`

                Comparison operator

                - `const FilterConditionOperatorEquals FilterConditionOperator = "="`

                - `const FilterConditionOperatorNotEquals FilterConditionOperator = "!="`

                - `const FilterConditionOperatorGreater FilterConditionOperator = ">"`

                - `const FilterConditionOperatorLess FilterConditionOperator = "<"`

                - `const FilterConditionOperatorGreaterOrEquals FilterConditionOperator = ">="`

                - `const FilterConditionOperatorLessOrEquals FilterConditionOperator = "<="`

                - `const FilterConditionOperatorIn FilterConditionOperator = "IN"`

                - `const FilterConditionOperatorNotIn FilterConditionOperator = "NOT IN"`

                - `const FilterConditionOperatorLike FilterConditionOperator = "LIKE"`

                - `const FilterConditionOperatorNotLike FilterConditionOperator = "NOT LIKE"`

                - `const FilterConditionOperatorIsNull FilterConditionOperator = "IS NULL"`

                - `const FilterConditionOperatorIsNotNull FilterConditionOperator = "IS NOT NULL"`

              - `Source string`

                Column source: 'data' or 'task_result_cache'

              - `Value FilterConditionValueUnion`

                Value to compare against. Not required for IS NULL / IS NOT NULL operators.

                - `string`

                - `float64`

                - `bool`

                - `type FilterConditionValueArray []any`

            - `LogicalOperators []string`

              Logical operators connecting conditions. Length must be len(conditions) - 1

              - `const FilterLogicalOperatorAnd FilterLogicalOperator = "AND"`

              - `const FilterLogicalOperatorOr FilterLogicalOperator = "OR"`

          - `GroupBy []string`

            Columns to group by

          - `LatestOnly bool`

            When True, the widget computes against rows from only the most recent active evaluation in the group (by EvaluationORM.created_at). Only applicable for evaluation group dashboards. Composes with evaluation_ids (latest within the subset). Cannot be combined with per-aggregation evaluation_ids; the use case enforces these rules.

          - `Limit int64`

            Max rows to return

          - `OrderBy []SeriesQueryOrderBy`

            Sort order

            - `Column string`

              Column name to sort by

            - `Direction string`

              Sort direction

              - `const SeriesQueryOrderByDirectionAsc SeriesQueryOrderByDirection = "ASC"`

              - `const SeriesQueryOrderByDirectionDesc SeriesQueryOrderByDirection = "DESC"`

            - `Source string`

              Column source: 'data' or 'task_result_cache'

        - `type MetricQuery struct{…}`

          Query that returns a single metric value (used for metric widgets).

          Used for widget type: metric.
          Enforces exactly 1 aggregation in select.
          Returns: {"type": "metric", "data": ...}

          Example SQL equivalent:
          SELECT AVG(score) as average_score
          FROM evaluation_items

          - `Select []SelectItem`

            - `Expression SelectItemExpressionUnion`

              Reference to a column from evaluation_items.data

              Example:
              {"type": "COLUMN", "column": "category"}

            - `Alias string`

              Optional alias for the selected item

          - `EvaluationIDs []string`

            Optional subset of evaluation IDs to compute on. Only applicable for evaluation group dashboards. If omitted, computes on all evaluations in the group.

          - `Filter Filter`

            Filter conditions (WHERE clause)

          - `LatestOnly bool`

            When True, the widget computes against rows from only the most recent active evaluation in the group (by EvaluationORM.created_at). Only applicable for evaluation group dashboards. Composes with evaluation_ids (latest within the subset). Cannot be combined with per-aggregation evaluation_ids; the use case enforces these rules.

  - `Widgets []EvaluationDashboardWidget`

    Widgets associated with this dashboard. Populated with 'widgets' view.

    - `ID string`

      Unique identifier of the widget

    - `AccountID string`

      Account that owns this widget

    - `CreatedAt Time`

      When the widget was created

    - `Title string`

      Widget title

    - `Type EvaluationWidgetTypeEnum`

      Widget type

    - `ArchivedAt Time`

      When the widget was archived (soft-deleted)

    - `Config map[string, any]`

      Chart-specific display configuration

    - `Object EvaluationDashboardWidgetObject`

    - `Query EvaluationDashboardWidgetQueryUnion`

      Structured query AST for metric computation (SeriesQuery or MetricQuery)

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/scaleapi/sgp-dev-go"
  "github.com/scaleapi/sgp-dev-go/option"
)

func main() {
  client := sgpdev.NewClient(
    option.WithAPIKey("My API Key"),
    option.WithAccountID("My Account ID"),
  )
  evaluationDashboard, err := client.EvaluationDashboards.Archive(context.TODO(), "dashboard_id")
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", evaluationDashboard.ID)
}
```

#### Response

```json
{
  "id": "id",
  "account_id": "account_id",
  "created_at": "2019-12-27T18:11:19.117Z",
  "created_by": {
    "id": "id",
    "type": "user",
    "object": "identity"
  },
  "name": "name",
  "tags": [
    "string"
  ],
  "updated_at": "2019-12-27T18:11:19.117Z",
  "archived_at": "2019-12-27T18:11:19.117Z",
  "description": "description",
  "error_message": "error_message",
  "evaluation_group_id": "evaluation_group_id",
  "evaluation_id": "evaluation_id",
  "object": "evaluation_dashboard",
  "widget_order": [
    "string"
  ],
  "widget_results": [
    {
      "id": "id",
      "account_id": "account_id",
      "computation_status": "pending",
      "created_at": "2019-12-27T18:11:19.117Z",
      "widget_id": "widget_id",
      "computation_job_id": "computation_job_id",
      "computed_at": "2019-12-27T18:11:19.117Z",
      "computed_result": {
        "foo": "bar"
      },
      "error_message": "error_message",
      "evaluation_group_id": "evaluation_group_id",
      "evaluation_id": "evaluation_id",
      "object": "evaluation_dashboard_widget_result",
      "widget": {
        "id": "id",
        "account_id": "account_id",
        "created_at": "2019-12-27T18:11:19.117Z",
        "title": "title",
        "type": "bar",
        "archived_at": "2019-12-27T18:11:19.117Z",
        "config": {
          "foo": "bar"
        },
        "object": "evaluation_dashboard_widget",
        "query": {
          "select": [
            {
              "expression": {
                "column": "column",
                "source": "source",
                "type": "COLUMN"
              },
              "alias": "alias"
            }
          ],
          "evaluation_ids": [
            "string"
          ],
          "filter": {
            "conditions": [
              {
                "column": "column",
                "operator": "=",
                "source": "source",
                "value": "string"
              }
            ],
            "logicalOperators": [
              "AND"
            ]
          },
          "groupBy": [
            "string"
          ],
          "latest_only": true,
          "limit": 1,
          "orderBy": [
            {
              "column": "column",
              "direction": "ASC",
              "source": "source"
            }
          ]
        }
      }
    }
  ],
  "widgets": [
    {
      "id": "id",
      "account_id": "account_id",
      "created_at": "2019-12-27T18:11:19.117Z",
      "title": "title",
      "type": "bar",
      "archived_at": "2019-12-27T18:11:19.117Z",
      "config": {
        "foo": "bar"
      },
      "object": "evaluation_dashboard_widget",
      "query": {
        "select": [
          {
            "expression": {
              "column": "column",
              "source": "source",
              "type": "COLUMN"
            },
            "alias": "alias"
          }
        ],
        "evaluation_ids": [
          "string"
        ],
        "filter": {
          "conditions": [
            {
              "column": "column",
              "operator": "=",
              "source": "source",
              "value": "string"
            }
          ],
          "logicalOperators": [
            "AND"
          ]
        },
        "groupBy": [
          "string"
        ],
        "latest_only": true,
        "limit": 1,
        "orderBy": [
          {
            "column": "column",
            "direction": "ASC",
            "source": "source"
          }
        ]
      }
    }
  ]
}
```
