# Page Shield

## Get Page Shield settings

`client.PageShield.Get(ctx, query) (*Setting, error)`

**get** `/zones/{zone_id}/page_shield`

Fetches the Page Shield settings.

### Parameters

- `query PageShieldGetParams`

  - `ZoneID param.Field[string]`

    Identifier

### Returns

- `type Setting struct{…}`

  - `Enabled bool`

    When true, indicates that Page Shield is enabled.

  - `UpdatedAt string`

    The timestamp of when Page Shield was last updated.

  - `UseCloudflareReportingEndpoint bool`

    When true, CSP reports will be sent to https://csp-reporting.cloudflare.com/cdn-cgi/script_monitor/report

  - `UseConnectionURLPath bool`

    When true, the paths associated with connections URLs will also be analyzed.

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/cloudflare/cloudflare-go"
  "github.com/cloudflare/cloudflare-go/option"
  "github.com/cloudflare/cloudflare-go/page_shield"
)

func main() {
  client := cloudflare.NewClient(
    option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
    option.WithAPIEmail("user@example.com"),
  )
  setting, err := client.PageShield.Get(context.TODO(), page_shield.PageShieldGetParams{
    ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", setting.Enabled)
}
```

#### Response

```json
{
  "success": true,
  "errors": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "result": {
    "enabled": true,
    "updated_at": "2022-10-12T17:56:52.083582+01:00",
    "use_cloudflare_reporting_endpoint": true,
    "use_connection_url_path": true
  }
}
```

## Update Page Shield settings

`client.PageShield.Update(ctx, params) (*PageShieldUpdateResponse, error)`

**put** `/zones/{zone_id}/page_shield`

Updates Page Shield settings.

### Parameters

- `params PageShieldUpdateParams`

  - `ZoneID param.Field[string]`

    Path param: Identifier

  - `Enabled param.Field[bool]`

    Body param: When true, indicates that Page Shield is enabled.

  - `UseCloudflareReportingEndpoint param.Field[bool]`

    Body param: When true, CSP reports will be sent to https://csp-reporting.cloudflare.com/cdn-cgi/script_monitor/report

  - `UseConnectionURLPath param.Field[bool]`

    Body param: When true, the paths associated with connections URLs will also be analyzed.

### Returns

- `type PageShieldUpdateResponse struct{…}`

  - `Enabled bool`

    When true, indicates that Page Shield is enabled.

  - `UpdatedAt string`

    The timestamp of when Page Shield was last updated.

  - `UseCloudflareReportingEndpoint bool`

    When true, CSP reports will be sent to https://csp-reporting.cloudflare.com/cdn-cgi/script_monitor/report

  - `UseConnectionURLPath bool`

    When true, the paths associated with connections URLs will also be analyzed.

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/cloudflare/cloudflare-go"
  "github.com/cloudflare/cloudflare-go/option"
  "github.com/cloudflare/cloudflare-go/page_shield"
)

func main() {
  client := cloudflare.NewClient(
    option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
    option.WithAPIEmail("user@example.com"),
  )
  pageShield, err := client.PageShield.Update(context.TODO(), page_shield.PageShieldUpdateParams{
    ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", pageShield.Enabled)
}
```

#### Response

```json
{
  "success": true,
  "errors": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "result": {
    "enabled": true,
    "updated_at": "2022-10-12T17:56:52.083582+01:00",
    "use_cloudflare_reporting_endpoint": true,
    "use_connection_url_path": true
  }
}
```

## Domain Types

### Setting

- `type Setting struct{…}`

  - `Enabled bool`

    When true, indicates that Page Shield is enabled.

  - `UpdatedAt string`

    The timestamp of when Page Shield was last updated.

  - `UseCloudflareReportingEndpoint bool`

    When true, CSP reports will be sent to https://csp-reporting.cloudflare.com/cdn-cgi/script_monitor/report

  - `UseConnectionURLPath bool`

    When true, the paths associated with connections URLs will also be analyzed.

# Policies

## List Page Shield policies

`client.PageShield.Policies.List(ctx, query) (*SinglePage[PolicyListResponse], error)`

**get** `/zones/{zone_id}/page_shield/policies`

Lists all Page Shield policies.

### Parameters

- `query PolicyListParams`

  - `ZoneID param.Field[string]`

    Identifier

### Returns

- `type PolicyListResponse struct{…}`

  - `ID string`

    Identifier

  - `Action PolicyListResponseAction`

    The action to take if the expression matches

    - `const PolicyListResponseActionAllow PolicyListResponseAction = "allow"`

    - `const PolicyListResponseActionLog PolicyListResponseAction = "log"`

    - `const PolicyListResponseActionAddReportingDirectives PolicyListResponseAction = "add_reporting_directives"`

  - `Description string`

    A description for the policy

  - `Enabled bool`

    Whether the policy is enabled

  - `Expression string`

    The expression which must match for the policy to be applied, using the Cloudflare Firewall rule expression syntax

  - `Value string`

    The policy which will be applied

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/cloudflare/cloudflare-go"
  "github.com/cloudflare/cloudflare-go/option"
  "github.com/cloudflare/cloudflare-go/page_shield"
)

func main() {
  client := cloudflare.NewClient(
    option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
    option.WithAPIEmail("user@example.com"),
  )
  page, err := client.PageShield.Policies.List(context.TODO(), page_shield.PolicyListParams{
    ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", page)
}
```

#### Response

```json
{
  "result": [
    {
      "id": "023e105f4ecef8ad9ca31a8372d0c353",
      "action": "allow",
      "description": "Checkout page CSP policy",
      "enabled": true,
      "expression": "ends_with(http.request.uri.path, \"/checkout\")",
      "value": "script-src 'none';"
    }
  ],
  "result_info": {
    "count": 1,
    "page": 1,
    "per_page": 20,
    "total_count": 2000,
    "total_pages": 100
  },
  "success": true,
  "errors": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ]
}
```

## Get a Page Shield policy

`client.PageShield.Policies.Get(ctx, policyID, query) (*PolicyGetResponse, error)`

**get** `/zones/{zone_id}/page_shield/policies/{policy_id}`

Fetches a Page Shield policy by ID.

### Parameters

- `policyID string`

  Identifier

- `query PolicyGetParams`

  - `ZoneID param.Field[string]`

    Identifier

### Returns

- `type PolicyGetResponse struct{…}`

  - `ID string`

    Identifier

  - `Action PolicyGetResponseAction`

    The action to take if the expression matches

    - `const PolicyGetResponseActionAllow PolicyGetResponseAction = "allow"`

    - `const PolicyGetResponseActionLog PolicyGetResponseAction = "log"`

    - `const PolicyGetResponseActionAddReportingDirectives PolicyGetResponseAction = "add_reporting_directives"`

  - `Description string`

    A description for the policy

  - `Enabled bool`

    Whether the policy is enabled

  - `Expression string`

    The expression which must match for the policy to be applied, using the Cloudflare Firewall rule expression syntax

  - `Value string`

    The policy which will be applied

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/cloudflare/cloudflare-go"
  "github.com/cloudflare/cloudflare-go/option"
  "github.com/cloudflare/cloudflare-go/page_shield"
)

func main() {
  client := cloudflare.NewClient(
    option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
    option.WithAPIEmail("user@example.com"),
  )
  policy, err := client.PageShield.Policies.Get(
    context.TODO(),
    "023e105f4ecef8ad9ca31a8372d0c353",
    page_shield.PolicyGetParams{
      ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", policy.ID)
}
```

#### Response

```json
{
  "result": {
    "id": "023e105f4ecef8ad9ca31a8372d0c353",
    "action": "allow",
    "description": "Checkout page CSP policy",
    "enabled": true,
    "expression": "ends_with(http.request.uri.path, \"/checkout\")",
    "value": "script-src 'none';"
  },
  "success": true,
  "errors": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ]
}
```

## Create a Page Shield policy

`client.PageShield.Policies.New(ctx, params) (*PolicyNewResponse, error)`

**post** `/zones/{zone_id}/page_shield/policies`

Create a Page Shield policy.

### Parameters

- `params PolicyNewParams`

  - `ZoneID param.Field[string]`

    Path param: Identifier

  - `Policy param.Field[Policy]`

    Body param

### Returns

- `type PolicyNewResponse struct{…}`

  - `ID string`

    Identifier

  - `Action PolicyNewResponseAction`

    The action to take if the expression matches

    - `const PolicyNewResponseActionAllow PolicyNewResponseAction = "allow"`

    - `const PolicyNewResponseActionLog PolicyNewResponseAction = "log"`

    - `const PolicyNewResponseActionAddReportingDirectives PolicyNewResponseAction = "add_reporting_directives"`

  - `Description string`

    A description for the policy

  - `Enabled bool`

    Whether the policy is enabled

  - `Expression string`

    The expression which must match for the policy to be applied, using the Cloudflare Firewall rule expression syntax

  - `Value string`

    The policy which will be applied

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/cloudflare/cloudflare-go"
  "github.com/cloudflare/cloudflare-go/option"
  "github.com/cloudflare/cloudflare-go/page_shield"
)

func main() {
  client := cloudflare.NewClient(
    option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
    option.WithAPIEmail("user@example.com"),
  )
  policy, err := client.PageShield.Policies.New(context.TODO(), page_shield.PolicyNewParams{
    ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
    Policy: page_shield.PolicyParam{
      Action: cloudflare.F(page_shield.PolicyActionAllow),
      Description: cloudflare.F("Checkout page CSP policy"),
      Enabled: cloudflare.F(true),
      Expression: cloudflare.F(`ends_with(http.request.uri.path, "/checkout")`),
      Value: cloudflare.F("script-src 'none';"),
    },
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", policy.ID)
}
```

#### Response

```json
{
  "result": {
    "id": "023e105f4ecef8ad9ca31a8372d0c353",
    "action": "allow",
    "description": "Checkout page CSP policy",
    "enabled": true,
    "expression": "ends_with(http.request.uri.path, \"/checkout\")",
    "value": "script-src 'none';"
  },
  "success": true,
  "errors": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ]
}
```

## Update a Page Shield policy

`client.PageShield.Policies.Update(ctx, policyID, params) (*PolicyUpdateResponse, error)`

**put** `/zones/{zone_id}/page_shield/policies/{policy_id}`

Update a Page Shield policy by ID.

### Parameters

- `policyID string`

  Identifier

- `params PolicyUpdateParams`

  - `ZoneID param.Field[string]`

    Path param: Identifier

  - `Action param.Field[PolicyUpdateParamsAction]`

    Body param: The action to take if the expression matches

    - `const PolicyUpdateParamsActionAllow PolicyUpdateParamsAction = "allow"`

    - `const PolicyUpdateParamsActionLog PolicyUpdateParamsAction = "log"`

    - `const PolicyUpdateParamsActionAddReportingDirectives PolicyUpdateParamsAction = "add_reporting_directives"`

  - `Description param.Field[string]`

    Body param: A description for the policy

  - `Enabled param.Field[bool]`

    Body param: Whether the policy is enabled

  - `Expression param.Field[string]`

    Body param: The expression which must match for the policy to be applied, using the Cloudflare Firewall rule expression syntax

  - `Value param.Field[string]`

    Body param: The policy which will be applied

### Returns

- `type PolicyUpdateResponse struct{…}`

  - `ID string`

    Identifier

  - `Action PolicyUpdateResponseAction`

    The action to take if the expression matches

    - `const PolicyUpdateResponseActionAllow PolicyUpdateResponseAction = "allow"`

    - `const PolicyUpdateResponseActionLog PolicyUpdateResponseAction = "log"`

    - `const PolicyUpdateResponseActionAddReportingDirectives PolicyUpdateResponseAction = "add_reporting_directives"`

  - `Description string`

    A description for the policy

  - `Enabled bool`

    Whether the policy is enabled

  - `Expression string`

    The expression which must match for the policy to be applied, using the Cloudflare Firewall rule expression syntax

  - `Value string`

    The policy which will be applied

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/cloudflare/cloudflare-go"
  "github.com/cloudflare/cloudflare-go/option"
  "github.com/cloudflare/cloudflare-go/page_shield"
)

func main() {
  client := cloudflare.NewClient(
    option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
    option.WithAPIEmail("user@example.com"),
  )
  policy, err := client.PageShield.Policies.Update(
    context.TODO(),
    "023e105f4ecef8ad9ca31a8372d0c353",
    page_shield.PolicyUpdateParams{
      ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", policy.ID)
}
```

#### Response

```json
{
  "result": {
    "id": "023e105f4ecef8ad9ca31a8372d0c353",
    "action": "allow",
    "description": "Checkout page CSP policy",
    "enabled": true,
    "expression": "ends_with(http.request.uri.path, \"/checkout\")",
    "value": "script-src 'none';"
  },
  "success": true,
  "errors": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ]
}
```

## Delete a Page Shield policy

`client.PageShield.Policies.Delete(ctx, policyID, body) error`

**delete** `/zones/{zone_id}/page_shield/policies/{policy_id}`

Delete a Page Shield policy by ID.

### Parameters

- `policyID string`

  Identifier

- `body PolicyDeleteParams`

  - `ZoneID param.Field[string]`

    Identifier

### Example

```go
package main

import (
  "context"

  "github.com/cloudflare/cloudflare-go"
  "github.com/cloudflare/cloudflare-go/option"
  "github.com/cloudflare/cloudflare-go/page_shield"
)

func main() {
  client := cloudflare.NewClient(
    option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
    option.WithAPIEmail("user@example.com"),
  )
  err := client.PageShield.Policies.Delete(
    context.TODO(),
    "023e105f4ecef8ad9ca31a8372d0c353",
    page_shield.PolicyDeleteParams{
      ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
}
```

## Domain Types

### Policy

- `type Policy struct{…}`

  - `Action PolicyAction`

    The action to take if the expression matches

    - `const PolicyActionAllow PolicyAction = "allow"`

    - `const PolicyActionLog PolicyAction = "log"`

    - `const PolicyActionAddReportingDirectives PolicyAction = "add_reporting_directives"`

  - `Description string`

    A description for the policy

  - `Enabled bool`

    Whether the policy is enabled

  - `Expression string`

    The expression which must match for the policy to be applied, using the Cloudflare Firewall rule expression syntax

  - `Value string`

    The policy which will be applied

# Connections

## List Page Shield connections

`client.PageShield.Connections.List(ctx, params) (*SinglePage[Connection], error)`

**get** `/zones/{zone_id}/page_shield/connections`

Lists all connections detected by Page Shield.

### Parameters

- `params ConnectionListParams`

  - `ZoneID param.Field[string]`

    Path param: Identifier

  - `Direction param.Field[ConnectionListParamsDirection]`

    Query param: The direction used to sort returned connections.

    - `const ConnectionListParamsDirectionAsc ConnectionListParamsDirection = "asc"`

    - `const ConnectionListParamsDirectionDesc ConnectionListParamsDirection = "desc"`

  - `ExcludeCDNCGI param.Field[bool]`

    Query param: When true, excludes connections seen in a `/cdn-cgi` path from the returned connections. The default value is true.

  - `ExcludeURLs param.Field[string]`

    Query param: Excludes connections whose URL contains one of the URL-encoded URLs separated by commas.

  - `Export param.Field[ConnectionListParamsExport]`

    Query param: Export the list of connections as a file, limited to 50000 entries.

    - `const ConnectionListParamsExportCsv ConnectionListParamsExport = "csv"`

  - `Hosts param.Field[string]`

    Query param: Includes connections that match one or more URL-encoded hostnames separated by commas.

    Wildcards are supported at the start and end of each hostname to support starts with, ends with
    and contains. If no wildcards are used, results will be filtered by exact match

  - `OrderBy param.Field[ConnectionListParamsOrderBy]`

    Query param: The field used to sort returned connections.

    - `const ConnectionListParamsOrderByFirstSeenAt ConnectionListParamsOrderBy = "first_seen_at"`

    - `const ConnectionListParamsOrderByLastSeenAt ConnectionListParamsOrderBy = "last_seen_at"`

  - `Page param.Field[string]`

    Query param: The current page number of the paginated results.

    We additionally support a special value "all". When "all" is used, the API will return all the connections
    with the applied filters in a single page. This feature is best-effort and it may only work for zones with
    a low number of connections

  - `PageURL param.Field[string]`

    Query param: Includes connections that match one or more page URLs (separated by commas) where they were last seen

    Wildcards are supported at the start and end of each page URL to support starts with, ends with
    and contains. If no wildcards are used, results will be filtered by exact match

  - `PerPage param.Field[float64]`

    Query param: The number of results per page.

  - `PrioritizeMalicious param.Field[bool]`

    Query param: When true, malicious connections appear first in the returned connections.

  - `Status param.Field[string]`

    Query param: Filters the returned connections using a comma-separated list of connection statuses. Accepted values: `active`, `infrequent`, and `inactive`. The default value is `active`.

  - `URLs param.Field[string]`

    Query param: Includes connections whose URL contain one or more URL-encoded URLs separated by commas.

### Returns

- `type Connection struct{…}`

  - `ID string`

    Identifier

  - `AddedAt Time`

  - `FirstSeenAt Time`

  - `Host string`

  - `LastSeenAt Time`

  - `URL string`

  - `URLContainsCDNCGIPath bool`

  - `DomainReportedMalicious bool`

  - `FirstPageURL string`

  - `MaliciousDomainCategories []string`

  - `MaliciousURLCategories []string`

  - `PageURLs []string`

  - `URLReportedMalicious bool`

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/cloudflare/cloudflare-go"
  "github.com/cloudflare/cloudflare-go/option"
  "github.com/cloudflare/cloudflare-go/page_shield"
)

func main() {
  client := cloudflare.NewClient(
    option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
    option.WithAPIEmail("user@example.com"),
  )
  page, err := client.PageShield.Connections.List(context.TODO(), page_shield.ConnectionListParams{
    ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", page)
}
```

#### Response

```json
{
  "result_info": {
    "count": 1,
    "page": 1,
    "per_page": 20,
    "total_count": 2000,
    "total_pages": 100
  },
  "success": true,
  "errors": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "result": [
    {
      "id": "023e105f4ecef8ad9ca31a8372d0c353",
      "added_at": "2021-08-18T10:51:10.09615Z",
      "first_seen_at": "2021-08-18T10:51:08Z",
      "host": "blog.cloudflare.com",
      "last_seen_at": "2021-09-02T09:57:54Z",
      "url": "https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.6.0/js/bootstrap.min.js",
      "url_contains_cdn_cgi_path": false,
      "domain_reported_malicious": false,
      "first_page_url": "blog.cloudflare.com/page",
      "malicious_domain_categories": [
        "Malware"
      ],
      "malicious_url_categories": [
        "Malware"
      ],
      "page_urls": [
        "blog.cloudflare.com/page1",
        "blog.cloudflare.com/page2"
      ],
      "url_reported_malicious": false
    }
  ]
}
```

## Get a Page Shield connection

`client.PageShield.Connections.Get(ctx, connectionID, query) (*Connection, error)`

**get** `/zones/{zone_id}/page_shield/connections/{connection_id}`

Fetches a connection detected by Page Shield by connection ID.

### Parameters

- `connectionID string`

  Identifier

- `query ConnectionGetParams`

  - `ZoneID param.Field[string]`

    Identifier

### Returns

- `type Connection struct{…}`

  - `ID string`

    Identifier

  - `AddedAt Time`

  - `FirstSeenAt Time`

  - `Host string`

  - `LastSeenAt Time`

  - `URL string`

  - `URLContainsCDNCGIPath bool`

  - `DomainReportedMalicious bool`

  - `FirstPageURL string`

  - `MaliciousDomainCategories []string`

  - `MaliciousURLCategories []string`

  - `PageURLs []string`

  - `URLReportedMalicious bool`

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/cloudflare/cloudflare-go"
  "github.com/cloudflare/cloudflare-go/option"
  "github.com/cloudflare/cloudflare-go/page_shield"
)

func main() {
  client := cloudflare.NewClient(
    option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
    option.WithAPIEmail("user@example.com"),
  )
  connection, err := client.PageShield.Connections.Get(
    context.TODO(),
    "023e105f4ecef8ad9ca31a8372d0c353",
    page_shield.ConnectionGetParams{
      ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", connection.ID)
}
```

#### Response

```json
{
  "result": {
    "id": "023e105f4ecef8ad9ca31a8372d0c353",
    "added_at": "2021-08-18T10:51:10.09615Z",
    "first_seen_at": "2021-08-18T10:51:08Z",
    "host": "blog.cloudflare.com",
    "last_seen_at": "2021-09-02T09:57:54Z",
    "url": "https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.6.0/js/bootstrap.min.js",
    "url_contains_cdn_cgi_path": false,
    "domain_reported_malicious": false,
    "first_page_url": "blog.cloudflare.com/page",
    "malicious_domain_categories": [
      "Malware"
    ],
    "malicious_url_categories": [
      "Malware"
    ],
    "page_urls": [
      "blog.cloudflare.com/page1",
      "blog.cloudflare.com/page2"
    ],
    "url_reported_malicious": false
  },
  "success": true,
  "errors": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ]
}
```

## Domain Types

### Connection

- `type Connection struct{…}`

  - `ID string`

    Identifier

  - `AddedAt Time`

  - `FirstSeenAt Time`

  - `Host string`

  - `LastSeenAt Time`

  - `URL string`

  - `URLContainsCDNCGIPath bool`

  - `DomainReportedMalicious bool`

  - `FirstPageURL string`

  - `MaliciousDomainCategories []string`

  - `MaliciousURLCategories []string`

  - `PageURLs []string`

  - `URLReportedMalicious bool`

# Scripts

## List Page Shield scripts

`client.PageShield.Scripts.List(ctx, params) (*SinglePage[Script], error)`

**get** `/zones/{zone_id}/page_shield/scripts`

Lists all scripts detected by Page Shield.

### Parameters

- `params ScriptListParams`

  - `ZoneID param.Field[string]`

    Path param: Identifier

  - `Direction param.Field[ScriptListParamsDirection]`

    Query param: The direction used to sort returned scripts.

    - `const ScriptListParamsDirectionAsc ScriptListParamsDirection = "asc"`

    - `const ScriptListParamsDirectionDesc ScriptListParamsDirection = "desc"`

  - `ExcludeCDNCGI param.Field[bool]`

    Query param: When true, excludes scripts seen in a `/cdn-cgi` path from the returned scripts. The default value is true.

  - `ExcludeDuplicates param.Field[bool]`

    Query param: When true, excludes duplicate scripts. We consider a script duplicate of another if their javascript
    content matches and they share the same url host and zone hostname. In such case, we return the most
    recent script for the URL host and zone hostname combination.

  - `ExcludeURLs param.Field[string]`

    Query param: Excludes scripts whose URL contains one of the URL-encoded URLs separated by commas.

  - `Export param.Field[ScriptListParamsExport]`

    Query param: Export the list of scripts as a file, limited to 50000 entries.

    - `const ScriptListParamsExportCsv ScriptListParamsExport = "csv"`

  - `Hosts param.Field[string]`

    Query param: Includes scripts that match one or more URL-encoded hostnames separated by commas.

    Wildcards are supported at the start and end of each hostname to support starts with, ends with
    and contains. If no wildcards are used, results will be filtered by exact match

  - `OrderBy param.Field[ScriptListParamsOrderBy]`

    Query param: The field used to sort returned scripts.

    - `const ScriptListParamsOrderByFirstSeenAt ScriptListParamsOrderBy = "first_seen_at"`

    - `const ScriptListParamsOrderByLastSeenAt ScriptListParamsOrderBy = "last_seen_at"`

  - `Page param.Field[string]`

    Query param: The current page number of the paginated results.

    We additionally support a special value "all". When "all" is used, the API will return all the scripts
    with the applied filters in a single page. This feature is best-effort and it may only work for zones with
    a low number of scripts

  - `PageURL param.Field[string]`

    Query param: Includes scripts that match one or more page URLs (separated by commas) where they were last seen

    Wildcards are supported at the start and end of each page URL to support starts with, ends with
    and contains. If no wildcards are used, results will be filtered by exact match

  - `PerPage param.Field[float64]`

    Query param: The number of results per page.

  - `PrioritizeMalicious param.Field[bool]`

    Query param: When true, malicious scripts appear first in the returned scripts.

  - `Status param.Field[string]`

    Query param: Filters the returned scripts using a comma-separated list of scripts statuses. Accepted values: `active`, `infrequent`, and `inactive`. The default value is `active`.

  - `URLs param.Field[string]`

    Query param: Includes scripts whose URL contain one or more URL-encoded URLs separated by commas.

### Returns

- `type Script struct{…}`

  - `ID string`

    Identifier

  - `AddedAt Time`

  - `FirstSeenAt Time`

  - `Host string`

  - `LastSeenAt Time`

  - `URL string`

  - `URLContainsCDNCGIPath bool`

  - `CryptominingScore int64`

    The cryptomining score of the JavaScript content.

  - `DataflowScore int64`

    The dataflow score of the JavaScript content. This field has been deprecated in favour of js_integrity_score.

  - `DomainReportedMalicious bool`

  - `FetchedAt string`

    The timestamp of when the script was last fetched.

  - `FirstPageURL string`

  - `Hash string`

    The computed hash of the analyzed script.

  - `JSIntegrityScore int64`

    The integrity score of the JavaScript content.

  - `MagecartScore int64`

    The magecart score of the JavaScript content.

  - `MaliciousDomainCategories []string`

  - `MaliciousURLCategories []string`

  - `MalwareScore int64`

    The malware score of the JavaScript content.

  - `ObfuscationScore int64`

    The obfuscation score of the JavaScript content. This field has been deprecated in favour of js_integrity_score.

  - `PageURLs []string`

  - `URLReportedMalicious bool`

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/cloudflare/cloudflare-go"
  "github.com/cloudflare/cloudflare-go/option"
  "github.com/cloudflare/cloudflare-go/page_shield"
)

func main() {
  client := cloudflare.NewClient(
    option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
    option.WithAPIEmail("user@example.com"),
  )
  page, err := client.PageShield.Scripts.List(context.TODO(), page_shield.ScriptListParams{
    ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", page)
}
```

#### Response

```json
{
  "result": [
    {
      "id": "023e105f4ecef8ad9ca31a8372d0c353",
      "added_at": "2021-08-18T10:51:10.09615Z",
      "first_seen_at": "2021-08-18T10:51:08Z",
      "host": "blog.cloudflare.com",
      "last_seen_at": "2021-09-02T09:57:54Z",
      "url": "https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.6.0/js/bootstrap.min.js",
      "url_contains_cdn_cgi_path": false,
      "cryptomining_score": 1,
      "dataflow_score": 1,
      "domain_reported_malicious": false,
      "fetched_at": "fetched_at",
      "first_page_url": "blog.cloudflare.com/page",
      "hash": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
      "js_integrity_score": 1,
      "magecart_score": 1,
      "malicious_domain_categories": [
        "Malware"
      ],
      "malicious_url_categories": [
        "Malware"
      ],
      "malware_score": 1,
      "obfuscation_score": 1,
      "page_urls": [
        "blog.cloudflare.com/page1",
        "blog.cloudflare.com/page2"
      ],
      "url_reported_malicious": false
    }
  ],
  "result_info": {
    "count": 1,
    "page": 1,
    "per_page": 20,
    "total_count": 2000,
    "total_pages": 100
  },
  "success": true,
  "errors": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ]
}
```

## Get a Page Shield script

`client.PageShield.Scripts.Get(ctx, scriptID, query) (*ScriptGetResponse, error)`

**get** `/zones/{zone_id}/page_shield/scripts/{script_id}`

Fetches a script detected by Page Shield by script ID.

### Parameters

- `scriptID string`

  Identifier

- `query ScriptGetParams`

  - `ZoneID param.Field[string]`

    Identifier

### Returns

- `type ScriptGetResponse struct{…}`

  - `ID string`

    Identifier

  - `AddedAt Time`

  - `FirstSeenAt Time`

  - `Host string`

  - `LastSeenAt Time`

  - `URL string`

  - `URLContainsCDNCGIPath bool`

  - `CryptominingScore int64`

    The cryptomining score of the JavaScript content.

  - `DataflowScore int64`

    The dataflow score of the JavaScript content. This field has been deprecated in favour of js_integrity_score.

  - `DomainReportedMalicious bool`

  - `FetchedAt string`

    The timestamp of when the script was last fetched.

  - `FirstPageURL string`

  - `Hash string`

    The computed hash of the analyzed script.

  - `JSIntegrityScore int64`

    The integrity score of the JavaScript content.

  - `MagecartScore int64`

    The magecart score of the JavaScript content.

  - `MaliciousDomainCategories []string`

  - `MaliciousURLCategories []string`

  - `MalwareScore int64`

    The malware score of the JavaScript content.

  - `ObfuscationScore int64`

    The obfuscation score of the JavaScript content. This field has been deprecated in favour of js_integrity_score.

  - `PageURLs []string`

  - `URLReportedMalicious bool`

  - `Versions []ScriptGetResponseVersion`

    - `CryptominingScore int64`

      The cryptomining score of the JavaScript content.

    - `DataflowScore int64`

      The dataflow score of the JavaScript content. This field has been deprecated in favour of js_integrity_score.

    - `FetchedAt string`

      The timestamp of when the script was last fetched.

    - `Hash string`

      The computed hash of the analyzed script.

    - `JSIntegrityScore int64`

      The integrity score of the JavaScript content.

    - `MagecartScore int64`

      The magecart score of the JavaScript content.

    - `MalwareScore int64`

      The malware score of the JavaScript content.

    - `ObfuscationScore int64`

      The obfuscation score of the JavaScript content. This field has been deprecated in favour of js_integrity_score.

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/cloudflare/cloudflare-go"
  "github.com/cloudflare/cloudflare-go/option"
  "github.com/cloudflare/cloudflare-go/page_shield"
)

func main() {
  client := cloudflare.NewClient(
    option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
    option.WithAPIEmail("user@example.com"),
  )
  script, err := client.PageShield.Scripts.Get(
    context.TODO(),
    "023e105f4ecef8ad9ca31a8372d0c353",
    page_shield.ScriptGetParams{
      ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", script.ID)
}
```

#### Response

```json
{
  "result": {
    "id": "023e105f4ecef8ad9ca31a8372d0c353",
    "added_at": "2021-08-18T10:51:10.09615Z",
    "first_seen_at": "2021-08-18T10:51:08Z",
    "host": "blog.cloudflare.com",
    "last_seen_at": "2021-09-02T09:57:54Z",
    "url": "https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.6.0/js/bootstrap.min.js",
    "url_contains_cdn_cgi_path": false,
    "cryptomining_score": 1,
    "dataflow_score": 1,
    "domain_reported_malicious": false,
    "fetched_at": "fetched_at",
    "first_page_url": "blog.cloudflare.com/page",
    "hash": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    "js_integrity_score": 1,
    "magecart_score": 1,
    "malicious_domain_categories": [
      "Malware"
    ],
    "malicious_url_categories": [
      "Malware"
    ],
    "malware_score": 1,
    "obfuscation_score": 1,
    "page_urls": [
      "blog.cloudflare.com/page1",
      "blog.cloudflare.com/page2"
    ],
    "url_reported_malicious": false,
    "versions": [
      {
        "cryptomining_score": 20,
        "dataflow_score": 1,
        "fetched_at": "2021-08-18T10:51:08Z",
        "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b423",
        "js_integrity_score": 2,
        "magecart_score": 10,
        "malware_score": 5,
        "obfuscation_score": 1
      }
    ]
  },
  "success": true,
  "errors": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ]
}
```

## Domain Types

### Script

- `type Script struct{…}`

  - `ID string`

    Identifier

  - `AddedAt Time`

  - `FirstSeenAt Time`

  - `Host string`

  - `LastSeenAt Time`

  - `URL string`

  - `URLContainsCDNCGIPath bool`

  - `CryptominingScore int64`

    The cryptomining score of the JavaScript content.

  - `DataflowScore int64`

    The dataflow score of the JavaScript content. This field has been deprecated in favour of js_integrity_score.

  - `DomainReportedMalicious bool`

  - `FetchedAt string`

    The timestamp of when the script was last fetched.

  - `FirstPageURL string`

  - `Hash string`

    The computed hash of the analyzed script.

  - `JSIntegrityScore int64`

    The integrity score of the JavaScript content.

  - `MagecartScore int64`

    The magecart score of the JavaScript content.

  - `MaliciousDomainCategories []string`

  - `MaliciousURLCategories []string`

  - `MalwareScore int64`

    The malware score of the JavaScript content.

  - `ObfuscationScore int64`

    The obfuscation score of the JavaScript content. This field has been deprecated in favour of js_integrity_score.

  - `PageURLs []string`

  - `URLReportedMalicious bool`

# Cookies

## List Page Shield Cookies

`client.PageShield.Cookies.List(ctx, params) (*SinglePage[CookieListResponse], error)`

**get** `/zones/{zone_id}/page_shield/cookies`

Lists all cookies collected by Page Shield.

### Parameters

- `params CookieListParams`

  - `ZoneID param.Field[string]`

    Path param: Identifier

  - `Direction param.Field[CookieListParamsDirection]`

    Query param: The direction used to sort returned cookies.'

    - `const CookieListParamsDirectionAsc CookieListParamsDirection = "asc"`

    - `const CookieListParamsDirectionDesc CookieListParamsDirection = "desc"`

  - `Domain param.Field[string]`

    Query param: Filters the returned cookies that match the specified domain attribute

  - `Export param.Field[CookieListParamsExport]`

    Query param: Export the list of cookies as a file, limited to 50000 entries.

    - `const CookieListParamsExportCsv CookieListParamsExport = "csv"`

  - `Hosts param.Field[string]`

    Query param: Includes cookies that match one or more URL-encoded hostnames separated by commas.

    Wildcards are supported at the start and end of each hostname to support starts with, ends with
    and contains. If no wildcards are used, results will be filtered by exact match

  - `HTTPOnly param.Field[bool]`

    Query param: Filters the returned cookies that are set with HttpOnly

  - `Name param.Field[string]`

    Query param: Filters the returned cookies that match the specified name.
    Wildcards are supported at the start and end to support starts with, ends with
    and contains. e.g. session*

  - `OrderBy param.Field[CookieListParamsOrderBy]`

    Query param: The field used to sort returned cookies.

    - `const CookieListParamsOrderByFirstSeenAt CookieListParamsOrderBy = "first_seen_at"`

    - `const CookieListParamsOrderByLastSeenAt CookieListParamsOrderBy = "last_seen_at"`

  - `Page param.Field[string]`

    Query param: The current page number of the paginated results.

    We additionally support a special value "all". When "all" is used, the API will return all the cookies
    with the applied filters in a single page. This feature is best-effort and it may only work for zones with
    a low number of cookies

  - `PageURL param.Field[string]`

    Query param: Includes connections that match one or more page URLs (separated by commas) where they were last seen

    Wildcards are supported at the start and end of each page URL to support starts with, ends with
    and contains. If no wildcards are used, results will be filtered by exact match

  - `Path param.Field[string]`

    Query param: Filters the returned cookies that match the specified path attribute

  - `PerPage param.Field[float64]`

    Query param: The number of results per page.

  - `SameSite param.Field[CookieListParamsSameSite]`

    Query param: Filters the returned cookies that match the specified same_site attribute

    - `const CookieListParamsSameSiteLax CookieListParamsSameSite = "lax"`

    - `const CookieListParamsSameSiteStrict CookieListParamsSameSite = "strict"`

    - `const CookieListParamsSameSiteNone CookieListParamsSameSite = "none"`

  - `Secure param.Field[bool]`

    Query param: Filters the returned cookies that are set with Secure

  - `Type param.Field[CookieListParamsType]`

    Query param: Filters the returned cookies that match the specified type attribute

    - `const CookieListParamsTypeFirstParty CookieListParamsType = "first_party"`

    - `const CookieListParamsTypeUnknown CookieListParamsType = "unknown"`

### Returns

- `type CookieListResponse struct{…}`

  - `ID string`

    Identifier

  - `FirstSeenAt Time`

  - `Host string`

  - `LastSeenAt Time`

  - `Name string`

  - `Type CookieListResponseType`

    - `const CookieListResponseTypeFirstParty CookieListResponseType = "first_party"`

    - `const CookieListResponseTypeUnknown CookieListResponseType = "unknown"`

  - `DomainAttribute string`

  - `ExpiresAttribute Time`

  - `HTTPOnlyAttribute bool`

  - `MaxAgeAttribute int64`

  - `PageURLs []string`

  - `PathAttribute string`

  - `SameSiteAttribute CookieListResponseSameSiteAttribute`

    - `const CookieListResponseSameSiteAttributeLax CookieListResponseSameSiteAttribute = "lax"`

    - `const CookieListResponseSameSiteAttributeStrict CookieListResponseSameSiteAttribute = "strict"`

    - `const CookieListResponseSameSiteAttributeNone CookieListResponseSameSiteAttribute = "none"`

  - `SecureAttribute bool`

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/cloudflare/cloudflare-go"
  "github.com/cloudflare/cloudflare-go/option"
  "github.com/cloudflare/cloudflare-go/page_shield"
)

func main() {
  client := cloudflare.NewClient(
    option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
    option.WithAPIEmail("user@example.com"),
  )
  page, err := client.PageShield.Cookies.List(context.TODO(), page_shield.CookieListParams{
    ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", page)
}
```

#### Response

```json
{
  "result": [
    {
      "id": "023e105f4ecef8ad9ca31a8372d0c353",
      "first_seen_at": "2021-08-18T10:51:08Z",
      "host": "blog.cloudflare.com",
      "last_seen_at": "2021-09-02T09:57:54Z",
      "name": "session_id",
      "type": "first_party",
      "domain_attribute": "cloudflare.com",
      "expires_attribute": "2021-10-02T09:57:54Z",
      "http_only_attribute": true,
      "max_age_attribute": 3600,
      "page_urls": [
        "blog.cloudflare.com/page1",
        "blog.cloudflare.com/page2"
      ],
      "path_attribute": "/",
      "same_site_attribute": "strict",
      "secure_attribute": true
    }
  ],
  "result_info": {
    "count": 1,
    "page": 1,
    "per_page": 20,
    "total_count": 2000,
    "total_pages": 100
  },
  "success": true,
  "errors": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ]
}
```

## Get a Page Shield cookie

`client.PageShield.Cookies.Get(ctx, cookieID, query) (*CookieGetResponse, error)`

**get** `/zones/{zone_id}/page_shield/cookies/{cookie_id}`

Fetches a cookie collected by Page Shield by cookie ID.

### Parameters

- `cookieID string`

  Identifier

- `query CookieGetParams`

  - `ZoneID param.Field[string]`

    Identifier

### Returns

- `type CookieGetResponse struct{…}`

  - `ID string`

    Identifier

  - `FirstSeenAt Time`

  - `Host string`

  - `LastSeenAt Time`

  - `Name string`

  - `Type CookieGetResponseType`

    - `const CookieGetResponseTypeFirstParty CookieGetResponseType = "first_party"`

    - `const CookieGetResponseTypeUnknown CookieGetResponseType = "unknown"`

  - `DomainAttribute string`

  - `ExpiresAttribute Time`

  - `HTTPOnlyAttribute bool`

  - `MaxAgeAttribute int64`

  - `PageURLs []string`

  - `PathAttribute string`

  - `SameSiteAttribute CookieGetResponseSameSiteAttribute`

    - `const CookieGetResponseSameSiteAttributeLax CookieGetResponseSameSiteAttribute = "lax"`

    - `const CookieGetResponseSameSiteAttributeStrict CookieGetResponseSameSiteAttribute = "strict"`

    - `const CookieGetResponseSameSiteAttributeNone CookieGetResponseSameSiteAttribute = "none"`

  - `SecureAttribute bool`

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/cloudflare/cloudflare-go"
  "github.com/cloudflare/cloudflare-go/option"
  "github.com/cloudflare/cloudflare-go/page_shield"
)

func main() {
  client := cloudflare.NewClient(
    option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
    option.WithAPIEmail("user@example.com"),
  )
  cookie, err := client.PageShield.Cookies.Get(
    context.TODO(),
    "023e105f4ecef8ad9ca31a8372d0c353",
    page_shield.CookieGetParams{
      ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", cookie.ID)
}
```

#### Response

```json
{
  "result": {
    "id": "023e105f4ecef8ad9ca31a8372d0c353",
    "first_seen_at": "2021-08-18T10:51:08Z",
    "host": "blog.cloudflare.com",
    "last_seen_at": "2021-09-02T09:57:54Z",
    "name": "session_id",
    "type": "first_party",
    "domain_attribute": "cloudflare.com",
    "expires_attribute": "2021-10-02T09:57:54Z",
    "http_only_attribute": true,
    "max_age_attribute": 3600,
    "page_urls": [
      "blog.cloudflare.com/page1",
      "blog.cloudflare.com/page2"
    ],
    "path_attribute": "/",
    "same_site_attribute": "strict",
    "secure_attribute": true
  },
  "success": true,
  "errors": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    {
      "code": 1000,
      "message": "message",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ]
}
```