# Settings

## Get global schema validation settings

`client.SchemaValidation.Settings.Get(ctx, query) (*SettingGetResponse, error)`

**get** `/zones/{zone_id}/schema_validation/settings`

Retrieves the current global schema validation settings for a zone.

### Parameters

- `query SettingGetParams`

  - `ZoneID param.Field[string]`

    Identifier.

### Returns

- `type SettingGetResponse struct{…}`

  - `ValidationDefaultMitigationAction SettingGetResponseValidationDefaultMitigationAction`

    The default mitigation action used

    Mitigation actions are as follows:

    - `log` - log request when request does not conform to schema
    - `block` - deny access to the site when request does not conform to schema
    - `none` - skip running schema validation

    - `const SettingGetResponseValidationDefaultMitigationActionNone SettingGetResponseValidationDefaultMitigationAction = "none"`

    - `const SettingGetResponseValidationDefaultMitigationActionLog SettingGetResponseValidationDefaultMitigationAction = "log"`

    - `const SettingGetResponseValidationDefaultMitigationActionBlock SettingGetResponseValidationDefaultMitigationAction = "block"`

  - `ValidationOverrideMitigationAction SettingGetResponseValidationOverrideMitigationAction`

    When not null, this overrides global both zone level and operation level mitigation actions. This can serve as a quick way to disable schema validation for the whole zone.

    - `"none"` will skip running schema validation entirely for the request

    - `const SettingGetResponseValidationOverrideMitigationActionNone SettingGetResponseValidationOverrideMitigationAction = "none"`

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  setting, err := client.SchemaValidation.Settings.Get(context.TODO(), schema_validation.SettingGetParams{
    ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", setting.ValidationDefaultMitigationAction)
}
```

#### Response

```json
{
  "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": {
    "validation_default_mitigation_action": "block",
    "validation_override_mitigation_action": "none"
  },
  "success": true
}
```

## Update global schema validation settings

`client.SchemaValidation.Settings.Update(ctx, params) (*SettingUpdateResponse, error)`

**put** `/zones/{zone_id}/schema_validation/settings`

Fully updates global schema validation settings for a zone, replacing existing configuration.

### Parameters

- `params SettingUpdateParams`

  - `ZoneID param.Field[string]`

    Path param: Identifier.

  - `ValidationDefaultMitigationAction param.Field[SettingUpdateParamsValidationDefaultMitigationAction]`

    Body param: The default mitigation action used
    Mitigation actions are as follows:

    - `"log"` - log request when request does not conform to schema
    - `"block"` - deny access to the site when request does not conform to schema
    - `"none"` - skip running schema validation

    - `const SettingUpdateParamsValidationDefaultMitigationActionNone SettingUpdateParamsValidationDefaultMitigationAction = "none"`

    - `const SettingUpdateParamsValidationDefaultMitigationActionLog SettingUpdateParamsValidationDefaultMitigationAction = "log"`

    - `const SettingUpdateParamsValidationDefaultMitigationActionBlock SettingUpdateParamsValidationDefaultMitigationAction = "block"`

  - `ValidationOverrideMitigationAction param.Field[SettingUpdateParamsValidationOverrideMitigationAction]`

    Body param: When set, this overrides both zone level and operation level mitigation actions.

    - `"none"` - skip running schema validation entirely for the request
    - `null` - clears any existing override

    - `const SettingUpdateParamsValidationOverrideMitigationActionNone SettingUpdateParamsValidationOverrideMitigationAction = "none"`

### Returns

- `type SettingUpdateResponse struct{…}`

  - `ValidationDefaultMitigationAction SettingUpdateResponseValidationDefaultMitigationAction`

    The default mitigation action used

    Mitigation actions are as follows:

    - `log` - log request when request does not conform to schema
    - `block` - deny access to the site when request does not conform to schema
    - `none` - skip running schema validation

    - `const SettingUpdateResponseValidationDefaultMitigationActionNone SettingUpdateResponseValidationDefaultMitigationAction = "none"`

    - `const SettingUpdateResponseValidationDefaultMitigationActionLog SettingUpdateResponseValidationDefaultMitigationAction = "log"`

    - `const SettingUpdateResponseValidationDefaultMitigationActionBlock SettingUpdateResponseValidationDefaultMitigationAction = "block"`

  - `ValidationOverrideMitigationAction SettingUpdateResponseValidationOverrideMitigationAction`

    When not null, this overrides global both zone level and operation level mitigation actions. This can serve as a quick way to disable schema validation for the whole zone.

    - `"none"` will skip running schema validation entirely for the request

    - `const SettingUpdateResponseValidationOverrideMitigationActionNone SettingUpdateResponseValidationOverrideMitigationAction = "none"`

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  setting, err := client.SchemaValidation.Settings.Update(context.TODO(), schema_validation.SettingUpdateParams{
    ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
    ValidationDefaultMitigationAction: cloudflare.F(schema_validation.SettingUpdateParamsValidationDefaultMitigationActionBlock),
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", setting.ValidationDefaultMitigationAction)
}
```

#### Response

```json
{
  "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": {
    "validation_default_mitigation_action": "block",
    "validation_override_mitigation_action": "none"
  },
  "success": true
}
```

## Edit global schema validation settings

`client.SchemaValidation.Settings.Edit(ctx, params) (*SettingEditResponse, error)`

**patch** `/zones/{zone_id}/schema_validation/settings`

Partially updates global schema validation settings for a zone using PATCH semantics.

### Parameters

- `params SettingEditParams`

  - `ZoneID param.Field[string]`

    Path param: Identifier.

  - `ValidationDefaultMitigationAction param.Field[SettingEditParamsValidationDefaultMitigationAction]`

    Body param: The default mitigation action used
    Mitigation actions are as follows:

    - `"log"` - log request when request does not conform to schema
    - `"block"` - deny access to the site when request does not conform to schema
    - `"none"` - skip running schema validation

    - `const SettingEditParamsValidationDefaultMitigationActionNone SettingEditParamsValidationDefaultMitigationAction = "none"`

    - `const SettingEditParamsValidationDefaultMitigationActionLog SettingEditParamsValidationDefaultMitigationAction = "log"`

    - `const SettingEditParamsValidationDefaultMitigationActionBlock SettingEditParamsValidationDefaultMitigationAction = "block"`

  - `ValidationOverrideMitigationAction param.Field[SettingEditParamsValidationOverrideMitigationAction]`

    Body param: When set, this overrides both zone level and operation level mitigation actions.

    - `"none"` - skip running schema validation entirely for the request
    - `null` - clears any existing override

    - `const SettingEditParamsValidationOverrideMitigationActionNone SettingEditParamsValidationOverrideMitigationAction = "none"`

### Returns

- `type SettingEditResponse struct{…}`

  - `ValidationDefaultMitigationAction SettingEditResponseValidationDefaultMitigationAction`

    The default mitigation action used

    Mitigation actions are as follows:

    - `log` - log request when request does not conform to schema
    - `block` - deny access to the site when request does not conform to schema
    - `none` - skip running schema validation

    - `const SettingEditResponseValidationDefaultMitigationActionNone SettingEditResponseValidationDefaultMitigationAction = "none"`

    - `const SettingEditResponseValidationDefaultMitigationActionLog SettingEditResponseValidationDefaultMitigationAction = "log"`

    - `const SettingEditResponseValidationDefaultMitigationActionBlock SettingEditResponseValidationDefaultMitigationAction = "block"`

  - `ValidationOverrideMitigationAction SettingEditResponseValidationOverrideMitigationAction`

    When not null, this overrides global both zone level and operation level mitigation actions. This can serve as a quick way to disable schema validation for the whole zone.

    - `"none"` will skip running schema validation entirely for the request

    - `const SettingEditResponseValidationOverrideMitigationActionNone SettingEditResponseValidationOverrideMitigationAction = "none"`

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  response, err := client.SchemaValidation.Settings.Edit(context.TODO(), schema_validation.SettingEditParams{
    ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", response.ValidationDefaultMitigationAction)
}
```

#### Response

```json
{
  "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": {
    "validation_default_mitigation_action": "block",
    "validation_override_mitigation_action": "none"
  },
  "success": true
}
```

# Operations

## List per-operation schema validation settings

`client.SchemaValidation.Settings.Operations.List(ctx, params) (*V4PagePaginationArray[SettingOperationListResponse], error)`

**get** `/zones/{zone_id}/schema_validation/settings/operations`

Lists all per-operation schema validation settings configured for the zone.

### Parameters

- `params SettingOperationListParams`

  - `ZoneID param.Field[string]`

    Path param: Identifier.

  - `Page param.Field[int64]`

    Query param: Page number of paginated results.

  - `PerPage param.Field[int64]`

    Query param: Maximum number of results per page.

### Returns

- `type SettingOperationListResponse struct{…}`

  - `MitigationAction SettingOperationListResponseMitigationAction`

    When set, this applies a mitigation action to this operation which supersedes a global schema validation setting just for this operation

    - `"log"` - log request when request does not conform to schema for this operation
    - `"block"` - deny access to the site when request does not conform to schema for this operation
    - `"none"` - will skip mitigation for this operation

    - `const SettingOperationListResponseMitigationActionLog SettingOperationListResponseMitigationAction = "log"`

    - `const SettingOperationListResponseMitigationActionBlock SettingOperationListResponseMitigationAction = "block"`

    - `const SettingOperationListResponseMitigationActionNone SettingOperationListResponseMitigationAction = "none"`

  - `OperationID string`

    UUID.

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  page, err := client.SchemaValidation.Settings.Operations.List(context.TODO(), schema_validation.SettingOperationListParams{
    ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", page)
}
```

#### Response

```json
{
  "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": [
    {
      "mitigation_action": "block",
      "operation_id": "f174e90a-fafe-4643-bbbc-4a0ed4fc8415"
    }
  ],
  "success": true,
  "result_info": {
    "count": 1,
    "page": 1,
    "per_page": 20,
    "total_count": 2000,
    "total_pages": 100
  }
}
```

## Get per-operation schema validation setting

`client.SchemaValidation.Settings.Operations.Get(ctx, operationID, query) (*SettingOperationGetResponse, error)`

**get** `/zones/{zone_id}/schema_validation/settings/operations/{operation_id}`

Retrieves the schema validation settings configured for a specific API operation.

### Parameters

- `operationID string`

  UUID.

- `query SettingOperationGetParams`

  - `ZoneID param.Field[string]`

    Identifier.

### Returns

- `type SettingOperationGetResponse struct{…}`

  - `MitigationAction SettingOperationGetResponseMitigationAction`

    When set, this applies a mitigation action to this operation which supersedes a global schema validation setting just for this operation

    - `"log"` - log request when request does not conform to schema for this operation
    - `"block"` - deny access to the site when request does not conform to schema for this operation
    - `"none"` - will skip mitigation for this operation

    - `const SettingOperationGetResponseMitigationActionLog SettingOperationGetResponseMitigationAction = "log"`

    - `const SettingOperationGetResponseMitigationActionBlock SettingOperationGetResponseMitigationAction = "block"`

    - `const SettingOperationGetResponseMitigationActionNone SettingOperationGetResponseMitigationAction = "none"`

  - `OperationID string`

    UUID.

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  operation, err := client.SchemaValidation.Settings.Operations.Get(
    context.TODO(),
    "f174e90a-fafe-4643-bbbc-4a0ed4fc8415",
    schema_validation.SettingOperationGetParams{
      ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", operation.OperationID)
}
```

#### Response

```json
{
  "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": {
    "mitigation_action": "block",
    "operation_id": "f174e90a-fafe-4643-bbbc-4a0ed4fc8415"
  },
  "success": true
}
```

## Update per-operation schema validation setting

`client.SchemaValidation.Settings.Operations.Update(ctx, operationID, params) (*SettingOperationUpdateResponse, error)`

**put** `/zones/{zone_id}/schema_validation/settings/operations/{operation_id}`

Fully updates schema validation settings for a specific API operation.

### Parameters

- `operationID string`

  UUID.

- `params SettingOperationUpdateParams`

  - `ZoneID param.Field[string]`

    Path param: Identifier.

  - `MitigationAction param.Field[SettingOperationUpdateParamsMitigationAction]`

    Body param: When set, this applies a mitigation action to this operation

    - `"log"` - log request when request does not conform to schema for this operation
    - `"block"` - deny access to the site when request does not conform to schema for this operation
    - `"none"` - will skip mitigation for this operation
    - `null` - clears any mitigation action

    - `const SettingOperationUpdateParamsMitigationActionLog SettingOperationUpdateParamsMitigationAction = "log"`

    - `const SettingOperationUpdateParamsMitigationActionBlock SettingOperationUpdateParamsMitigationAction = "block"`

    - `const SettingOperationUpdateParamsMitigationActionNone SettingOperationUpdateParamsMitigationAction = "none"`

### Returns

- `type SettingOperationUpdateResponse struct{…}`

  - `MitigationAction SettingOperationUpdateResponseMitigationAction`

    When set, this applies a mitigation action to this operation which supersedes a global schema validation setting just for this operation

    - `"log"` - log request when request does not conform to schema for this operation
    - `"block"` - deny access to the site when request does not conform to schema for this operation
    - `"none"` - will skip mitigation for this operation

    - `const SettingOperationUpdateResponseMitigationActionLog SettingOperationUpdateResponseMitigationAction = "log"`

    - `const SettingOperationUpdateResponseMitigationActionBlock SettingOperationUpdateResponseMitigationAction = "block"`

    - `const SettingOperationUpdateResponseMitigationActionNone SettingOperationUpdateResponseMitigationAction = "none"`

  - `OperationID string`

    UUID.

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  operation, err := client.SchemaValidation.Settings.Operations.Update(
    context.TODO(),
    "f174e90a-fafe-4643-bbbc-4a0ed4fc8415",
    schema_validation.SettingOperationUpdateParams{
      ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
      MitigationAction: cloudflare.F(schema_validation.SettingOperationUpdateParamsMitigationActionBlock),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", operation.OperationID)
}
```

#### Response

```json
{
  "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": {
    "mitigation_action": "block",
    "operation_id": "f174e90a-fafe-4643-bbbc-4a0ed4fc8415"
  },
  "success": true
}
```

## Bulk edit per-operation schema validation settings

`client.SchemaValidation.Settings.Operations.BulkEdit(ctx, params) (*SettingOperationBulkEditResponse, error)`

**patch** `/zones/{zone_id}/schema_validation/settings/operations`

Updates schema validation settings for multiple API operations in a single request. Efficient for applying consistent validation rules across endpoints.

### Parameters

- `params SettingOperationBulkEditParams`

  - `ZoneID param.Field[string]`

    Path param: Identifier.

  - `Body param.Field[map[string, SettingOperationBulkEditParamsBody]]`

    Body param

    - `MitigationAction SettingOperationBulkEditParamsBodyMitigationAction`

      Mitigation actions are as follows:

      * `log` - log request when request does not conform to schema * `block` - deny access to the site when request does not conform to schema * `none` - skip running schema validation * null - clears any existing per-operation setting

      - `const SettingOperationBulkEditParamsBodyMitigationActionNone SettingOperationBulkEditParamsBodyMitigationAction = "none"`

      - `const SettingOperationBulkEditParamsBodyMitigationActionLog SettingOperationBulkEditParamsBodyMitigationAction = "log"`

      - `const SettingOperationBulkEditParamsBodyMitigationActionBlock SettingOperationBulkEditParamsBodyMitigationAction = "block"`

### Returns

- `type SettingOperationBulkEditResponse map[string, SettingOperationBulkEditResponseItem]`

  Operation ID to per operation setting mapping

  - `MitigationAction SettingOperationBulkEditResponseItemMitigationAction`

    When set, this applies a mitigation action to this operation which supersedes a global schema validation setting just for this operation

    - `"log"` - log request when request does not conform to schema for this operation
    - `"block"` - deny access to the site when request does not conform to schema for this operation
    - `"none"` - will skip mitigation for this operation

    - `const SettingOperationBulkEditResponseItemMitigationActionLog SettingOperationBulkEditResponseItemMitigationAction = "log"`

    - `const SettingOperationBulkEditResponseItemMitigationActionBlock SettingOperationBulkEditResponseItemMitigationAction = "block"`

    - `const SettingOperationBulkEditResponseItemMitigationActionNone SettingOperationBulkEditResponseItemMitigationAction = "none"`

  - `OperationID string`

    UUID.

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  response, err := client.SchemaValidation.Settings.Operations.BulkEdit(context.TODO(), schema_validation.SettingOperationBulkEditParams{
    ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
    Body: map[string]schema_validation.SettingOperationBulkEditParamsBody{
    "3818d821-5901-4147-a474-f5f5aec1d54e": schema_validation.SettingOperationBulkEditParamsBody{

    },
    "b17c8043-99a0-4202-b7d9-8f7cdbee02cd": schema_validation.SettingOperationBulkEditParamsBody{

    },
    },
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", response)
}
```

#### Response

```json
{
  "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": {
    "foo": {
      "mitigation_action": "block",
      "operation_id": "f174e90a-fafe-4643-bbbc-4a0ed4fc8415"
    }
  },
  "success": true
}
```

## Delete per-operation schema validation setting

`client.SchemaValidation.Settings.Operations.Delete(ctx, operationID, body) (*SettingOperationDeleteResponse, error)`

**delete** `/zones/{zone_id}/schema_validation/settings/operations/{operation_id}`

Removes custom schema validation settings for a specific API operation, reverting to zone-level defaults.

### Parameters

- `operationID string`

  UUID.

- `body SettingOperationDeleteParams`

  - `ZoneID param.Field[string]`

    Identifier.

### Returns

- `type SettingOperationDeleteResponse struct{…}`

  - `OperationID string`

    UUID.

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  operation, err := client.SchemaValidation.Settings.Operations.Delete(
    context.TODO(),
    "f174e90a-fafe-4643-bbbc-4a0ed4fc8415",
    schema_validation.SettingOperationDeleteParams{
      ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", operation.OperationID)
}
```

#### Response

```json
{
  "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": {
    "operation_id": "f174e90a-fafe-4643-bbbc-4a0ed4fc8415"
  },
  "success": true
}
```