# Super Slurper

# Jobs

## List jobs

`client.R2.SuperSlurper.Jobs.List(ctx, params) (*SinglePage[SuperSlurperJobListResponse], error)`

**get** `/accounts/{account_id}/slurper/jobs`

Lists all R2 Super Slurper migration jobs for the account with their status.

### Parameters

- `params SuperSlurperJobListParams`

  - `AccountID param.Field[string]`

    Path param

  - `Limit param.Field[int64]`

    Query param

  - `Offset param.Field[int64]`

    Query param

### Returns

- `type SuperSlurperJobListResponse struct{…}`

  - `ID string`

  - `CreatedAt string`

  - `FinishedAt string`

  - `Overwrite bool`

  - `Source SuperSlurperJobListResponseSource`

    - `type SuperSlurperJobListResponseSourceS3SourceResponseSchema struct{…}`

      - `Bucket string`

      - `Endpoint string`

      - `Keys []string`

      - `PathPrefix string`

      - `Vendor SuperSlurperJobListResponseSourceS3SourceResponseSchemaVendor`

        - `const SuperSlurperJobListResponseSourceS3SourceResponseSchemaVendorS3 SuperSlurperJobListResponseSourceS3SourceResponseSchemaVendor = "s3"`

    - `type SuperSlurperJobListResponseSourceGcsSourceResponseSchema struct{…}`

      - `Bucket string`

      - `Keys []string`

      - `PathPrefix string`

      - `Vendor SuperSlurperJobListResponseSourceGcsSourceResponseSchemaVendor`

        - `const SuperSlurperJobListResponseSourceGcsSourceResponseSchemaVendorGcs SuperSlurperJobListResponseSourceGcsSourceResponseSchemaVendor = "gcs"`

    - `type SuperSlurperJobListResponseSourceR2SourceResponseSchema struct{…}`

      - `Bucket string`

      - `Jurisdiction SuperSlurperJobListResponseSourceR2SourceResponseSchemaJurisdiction`

        - `const SuperSlurperJobListResponseSourceR2SourceResponseSchemaJurisdictionDefault SuperSlurperJobListResponseSourceR2SourceResponseSchemaJurisdiction = "default"`

        - `const SuperSlurperJobListResponseSourceR2SourceResponseSchemaJurisdictionEu SuperSlurperJobListResponseSourceR2SourceResponseSchemaJurisdiction = "eu"`

        - `const SuperSlurperJobListResponseSourceR2SourceResponseSchemaJurisdictionFedramp SuperSlurperJobListResponseSourceR2SourceResponseSchemaJurisdiction = "fedramp"`

      - `Keys []string`

      - `PathPrefix string`

      - `Vendor Provider`

        - `const ProviderR2 Provider = "r2"`

  - `Status SuperSlurperJobListResponseStatus`

    - `const SuperSlurperJobListResponseStatusRunning SuperSlurperJobListResponseStatus = "running"`

    - `const SuperSlurperJobListResponseStatusPaused SuperSlurperJobListResponseStatus = "paused"`

    - `const SuperSlurperJobListResponseStatusAborted SuperSlurperJobListResponseStatus = "aborted"`

    - `const SuperSlurperJobListResponseStatusCompleted SuperSlurperJobListResponseStatus = "completed"`

  - `Target SuperSlurperJobListResponseTarget`

    - `Bucket string`

    - `Jurisdiction SuperSlurperJobListResponseTargetJurisdiction`

      - `const SuperSlurperJobListResponseTargetJurisdictionDefault SuperSlurperJobListResponseTargetJurisdiction = "default"`

      - `const SuperSlurperJobListResponseTargetJurisdictionEu SuperSlurperJobListResponseTargetJurisdiction = "eu"`

      - `const SuperSlurperJobListResponseTargetJurisdictionFedramp SuperSlurperJobListResponseTargetJurisdiction = "fedramp"`

    - `Vendor Provider`

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  page, err := client.R2.SuperSlurper.Jobs.List(context.TODO(), r2.SuperSlurperJobListParams{
    AccountID: cloudflare.F("account_id"),
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", page)
}
```

#### Response

```json
{
  "errors": [
    {
      "code": 7003,
      "message": "No route for the URI",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    "string"
  ],
  "result": [
    {
      "id": "id",
      "createdAt": "createdAt",
      "finishedAt": "finishedAt",
      "overwrite": true,
      "source": {
        "bucket": "bucket",
        "endpoint": "endpoint",
        "keys": [
          "string"
        ],
        "pathPrefix": "pathPrefix",
        "vendor": "s3"
      },
      "status": "running",
      "target": {
        "bucket": "bucket",
        "jurisdiction": "default",
        "vendor": "r2"
      }
    }
  ],
  "success": true
}
```

## Get job details

`client.R2.SuperSlurper.Jobs.Get(ctx, jobID, query) (*SuperSlurperJobGetResponse, error)`

**get** `/accounts/{account_id}/slurper/jobs/{job_id}`

Retrieves detailed status and configuration for a specific R2 Super Slurper migration job.

### Parameters

- `jobID string`

- `query SuperSlurperJobGetParams`

  - `AccountID param.Field[string]`

### Returns

- `type SuperSlurperJobGetResponse struct{…}`

  - `ID string`

  - `CreatedAt string`

  - `FinishedAt string`

  - `Overwrite bool`

  - `Source SuperSlurperJobGetResponseSource`

    - `type SuperSlurperJobGetResponseSourceS3SourceResponseSchema struct{…}`

      - `Bucket string`

      - `Endpoint string`

      - `Keys []string`

      - `PathPrefix string`

      - `Vendor SuperSlurperJobGetResponseSourceS3SourceResponseSchemaVendor`

        - `const SuperSlurperJobGetResponseSourceS3SourceResponseSchemaVendorS3 SuperSlurperJobGetResponseSourceS3SourceResponseSchemaVendor = "s3"`

    - `type SuperSlurperJobGetResponseSourceGcsSourceResponseSchema struct{…}`

      - `Bucket string`

      - `Keys []string`

      - `PathPrefix string`

      - `Vendor SuperSlurperJobGetResponseSourceGcsSourceResponseSchemaVendor`

        - `const SuperSlurperJobGetResponseSourceGcsSourceResponseSchemaVendorGcs SuperSlurperJobGetResponseSourceGcsSourceResponseSchemaVendor = "gcs"`

    - `type SuperSlurperJobGetResponseSourceR2SourceResponseSchema struct{…}`

      - `Bucket string`

      - `Jurisdiction SuperSlurperJobGetResponseSourceR2SourceResponseSchemaJurisdiction`

        - `const SuperSlurperJobGetResponseSourceR2SourceResponseSchemaJurisdictionDefault SuperSlurperJobGetResponseSourceR2SourceResponseSchemaJurisdiction = "default"`

        - `const SuperSlurperJobGetResponseSourceR2SourceResponseSchemaJurisdictionEu SuperSlurperJobGetResponseSourceR2SourceResponseSchemaJurisdiction = "eu"`

        - `const SuperSlurperJobGetResponseSourceR2SourceResponseSchemaJurisdictionFedramp SuperSlurperJobGetResponseSourceR2SourceResponseSchemaJurisdiction = "fedramp"`

      - `Keys []string`

      - `PathPrefix string`

      - `Vendor Provider`

        - `const ProviderR2 Provider = "r2"`

  - `Status SuperSlurperJobGetResponseStatus`

    - `const SuperSlurperJobGetResponseStatusRunning SuperSlurperJobGetResponseStatus = "running"`

    - `const SuperSlurperJobGetResponseStatusPaused SuperSlurperJobGetResponseStatus = "paused"`

    - `const SuperSlurperJobGetResponseStatusAborted SuperSlurperJobGetResponseStatus = "aborted"`

    - `const SuperSlurperJobGetResponseStatusCompleted SuperSlurperJobGetResponseStatus = "completed"`

  - `Target SuperSlurperJobGetResponseTarget`

    - `Bucket string`

    - `Jurisdiction SuperSlurperJobGetResponseTargetJurisdiction`

      - `const SuperSlurperJobGetResponseTargetJurisdictionDefault SuperSlurperJobGetResponseTargetJurisdiction = "default"`

      - `const SuperSlurperJobGetResponseTargetJurisdictionEu SuperSlurperJobGetResponseTargetJurisdiction = "eu"`

      - `const SuperSlurperJobGetResponseTargetJurisdictionFedramp SuperSlurperJobGetResponseTargetJurisdiction = "fedramp"`

    - `Vendor Provider`

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  job, err := client.R2.SuperSlurper.Jobs.Get(
    context.TODO(),
    "job_id",
    r2.SuperSlurperJobGetParams{
      AccountID: cloudflare.F("account_id"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", job.ID)
}
```

#### Response

```json
{
  "errors": [
    {
      "code": 7003,
      "message": "No route for the URI",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    "string"
  ],
  "result": {
    "id": "id",
    "createdAt": "createdAt",
    "finishedAt": "finishedAt",
    "overwrite": true,
    "source": {
      "bucket": "bucket",
      "endpoint": "endpoint",
      "keys": [
        "string"
      ],
      "pathPrefix": "pathPrefix",
      "vendor": "s3"
    },
    "status": "running",
    "target": {
      "bucket": "bucket",
      "jurisdiction": "default",
      "vendor": "r2"
    }
  },
  "success": true
}
```

## Create a job

`client.R2.SuperSlurper.Jobs.New(ctx, params) (*SuperSlurperJobNewResponse, error)`

**post** `/accounts/{account_id}/slurper/jobs`

Creates a new R2 Super Slurper migration job to transfer objects from a source bucket (e.g. S3, GCS, R2) to R2.

### Parameters

- `params SuperSlurperJobNewParams`

  - `AccountID param.Field[string]`

    Path param

  - `Overwrite param.Field[bool]`

    Body param

  - `Source param.Field[SuperSlurperJobNewParamsSource]`

    Body param

    - `type SuperSlurperJobNewParamsSourceR2SlurperS3SourceSchema struct{…}`

      - `Bucket string`

      - `Secret SuperSlurperJobNewParamsSourceR2SlurperS3SourceSchemaSecret`

        - `AccessKeyID string`

        - `SecretAccessKey string`

      - `Vendor SuperSlurperJobNewParamsSourceR2SlurperS3SourceSchemaVendor`

        - `const SuperSlurperJobNewParamsSourceR2SlurperS3SourceSchemaVendorS3 SuperSlurperJobNewParamsSourceR2SlurperS3SourceSchemaVendor = "s3"`

      - `Endpoint string`

      - `Keys []string`

      - `PathPrefix string`

      - `Region string`

    - `type SuperSlurperJobNewParamsSourceR2SlurperGcsSourceSchema struct{…}`

      - `Bucket string`

      - `Secret SuperSlurperJobNewParamsSourceR2SlurperGcsSourceSchemaSecret`

        - `ClientEmail string`

        - `PrivateKey string`

      - `Vendor SuperSlurperJobNewParamsSourceR2SlurperGcsSourceSchemaVendor`

        - `const SuperSlurperJobNewParamsSourceR2SlurperGcsSourceSchemaVendorGcs SuperSlurperJobNewParamsSourceR2SlurperGcsSourceSchemaVendor = "gcs"`

      - `Keys []string`

      - `PathPrefix string`

    - `type SuperSlurperJobNewParamsSourceR2SlurperR2SourceSchema struct{…}`

      - `Bucket string`

      - `Secret SuperSlurperJobNewParamsSourceR2SlurperR2SourceSchemaSecret`

        - `AccessKeyID string`

        - `SecretAccessKey string`

      - `Vendor Provider`

        - `const ProviderR2 Provider = "r2"`

      - `Jurisdiction SuperSlurperJobNewParamsSourceR2SlurperR2SourceSchemaJurisdiction`

        - `const SuperSlurperJobNewParamsSourceR2SlurperR2SourceSchemaJurisdictionDefault SuperSlurperJobNewParamsSourceR2SlurperR2SourceSchemaJurisdiction = "default"`

        - `const SuperSlurperJobNewParamsSourceR2SlurperR2SourceSchemaJurisdictionEu SuperSlurperJobNewParamsSourceR2SlurperR2SourceSchemaJurisdiction = "eu"`

        - `const SuperSlurperJobNewParamsSourceR2SlurperR2SourceSchemaJurisdictionFedramp SuperSlurperJobNewParamsSourceR2SlurperR2SourceSchemaJurisdiction = "fedramp"`

      - `Keys []string`

      - `PathPrefix string`

  - `Target param.Field[SuperSlurperJobNewParamsTarget]`

    Body param

    - `Bucket string`

    - `Secret SuperSlurperJobNewParamsTargetSecret`

      - `AccessKeyID string`

      - `SecretAccessKey string`

    - `Vendor Provider`

    - `Jurisdiction SuperSlurperJobNewParamsTargetJurisdiction`

      - `const SuperSlurperJobNewParamsTargetJurisdictionDefault SuperSlurperJobNewParamsTargetJurisdiction = "default"`

      - `const SuperSlurperJobNewParamsTargetJurisdictionEu SuperSlurperJobNewParamsTargetJurisdiction = "eu"`

      - `const SuperSlurperJobNewParamsTargetJurisdictionFedramp SuperSlurperJobNewParamsTargetJurisdiction = "fedramp"`

### Returns

- `type SuperSlurperJobNewResponse struct{…}`

  - `ID string`

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  job, err := client.R2.SuperSlurper.Jobs.New(context.TODO(), r2.SuperSlurperJobNewParams{
    AccountID: cloudflare.F("account_id"),
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", job.ID)
}
```

#### Response

```json
{
  "errors": [
    {
      "code": 7003,
      "message": "No route for the URI",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    "string"
  ],
  "result": {
    "id": "id"
  },
  "success": true
}
```

## Abort all jobs

`client.R2.SuperSlurper.Jobs.AbortAll(ctx, body) (*string, error)`

**put** `/accounts/{account_id}/slurper/jobs/abortAll`

Cancels all running R2 Super Slurper migration jobs for the account. Any objects in the middle of a transfer will finish, but no new objects will start transferring.

### Parameters

- `body SuperSlurperJobAbortAllParams`

  - `AccountID param.Field[string]`

### Returns

- `type SuperSlurperJobAbortAllResponseEnvelopeResult string`

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  response, err := client.R2.SuperSlurper.Jobs.AbortAll(context.TODO(), r2.SuperSlurperJobAbortAllParams{
    AccountID: cloudflare.F("account_id"),
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", response)
}
```

#### Response

```json
{
  "errors": [
    {
      "code": 7003,
      "message": "No route for the URI",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    "string"
  ],
  "result": "result",
  "success": true
}
```

## Abort a job

`client.R2.SuperSlurper.Jobs.Abort(ctx, jobID, body) (*string, error)`

**put** `/accounts/{account_id}/slurper/jobs/{job_id}/abort`

Cancels a specific R2 Super Slurper migration job. Any objects in the middle of a transfer will finish, but no new objects will start transferring.

### Parameters

- `jobID string`

- `body SuperSlurperJobAbortParams`

  - `AccountID param.Field[string]`

### Returns

- `type SuperSlurperJobAbortResponseEnvelopeResult string`

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  response, err := client.R2.SuperSlurper.Jobs.Abort(
    context.TODO(),
    "job_id",
    r2.SuperSlurperJobAbortParams{
      AccountID: cloudflare.F("account_id"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", response)
}
```

#### Response

```json
{
  "errors": [
    {
      "code": 7003,
      "message": "No route for the URI",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    "string"
  ],
  "result": "result",
  "success": true
}
```

## Pause a job

`client.R2.SuperSlurper.Jobs.Pause(ctx, jobID, body) (*string, error)`

**put** `/accounts/{account_id}/slurper/jobs/{job_id}/pause`

Pauses a running R2 Super Slurper migration job. The job can be resumed later to continue transferring.

### Parameters

- `jobID string`

- `body SuperSlurperJobPauseParams`

  - `AccountID param.Field[string]`

### Returns

- `type SuperSlurperJobPauseResponseEnvelopeResult string`

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  response, err := client.R2.SuperSlurper.Jobs.Pause(
    context.TODO(),
    "job_id",
    r2.SuperSlurperJobPauseParams{
      AccountID: cloudflare.F("account_id"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", response)
}
```

#### Response

```json
{
  "errors": [
    {
      "code": 7003,
      "message": "No route for the URI",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    "string"
  ],
  "result": "result",
  "success": true
}
```

## Get job progress

`client.R2.SuperSlurper.Jobs.Progress(ctx, jobID, query) (*SuperSlurperJobProgressResponse, error)`

**get** `/accounts/{account_id}/slurper/jobs/{job_id}/progress`

Retrieves current progress metrics for an R2 Super Slurper migration job

### Parameters

- `jobID string`

- `query SuperSlurperJobProgressParams`

  - `AccountID param.Field[string]`

### Returns

- `type SuperSlurperJobProgressResponse struct{…}`

  - `ID string`

  - `CreatedAt string`

  - `FailedObjects int64`

  - `Objects int64`

  - `SkippedObjects int64`

  - `Status SuperSlurperJobProgressResponseStatus`

    - `const SuperSlurperJobProgressResponseStatusRunning SuperSlurperJobProgressResponseStatus = "running"`

    - `const SuperSlurperJobProgressResponseStatusPaused SuperSlurperJobProgressResponseStatus = "paused"`

    - `const SuperSlurperJobProgressResponseStatusAborted SuperSlurperJobProgressResponseStatus = "aborted"`

    - `const SuperSlurperJobProgressResponseStatusCompleted SuperSlurperJobProgressResponseStatus = "completed"`

  - `TransferredObjects int64`

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  response, err := client.R2.SuperSlurper.Jobs.Progress(
    context.TODO(),
    "job_id",
    r2.SuperSlurperJobProgressParams{
      AccountID: cloudflare.F("account_id"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", response.ID)
}
```

#### Response

```json
{
  "errors": [
    {
      "code": 7003,
      "message": "No route for the URI",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    "string"
  ],
  "result": {
    "id": "id",
    "createdAt": "createdAt",
    "failedObjects": 0,
    "objects": 0,
    "skippedObjects": 0,
    "status": "running",
    "transferredObjects": 0
  },
  "success": true
}
```

## Resume a job

`client.R2.SuperSlurper.Jobs.Resume(ctx, jobID, body) (*string, error)`

**put** `/accounts/{account_id}/slurper/jobs/{job_id}/resume`

Resumes a paused R2 Super Slurper migration job, continuing the transfer from where it stopped.

### Parameters

- `jobID string`

- `body SuperSlurperJobResumeParams`

  - `AccountID param.Field[string]`

### Returns

- `type SuperSlurperJobResumeResponseEnvelopeResult string`

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  response, err := client.R2.SuperSlurper.Jobs.Resume(
    context.TODO(),
    "job_id",
    r2.SuperSlurperJobResumeParams{
      AccountID: cloudflare.F("account_id"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", response)
}
```

#### Response

```json
{
  "errors": [
    {
      "code": 7003,
      "message": "No route for the URI",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    "string"
  ],
  "result": "result",
  "success": true
}
```

# Logs

## Get job logs

`client.R2.SuperSlurper.Jobs.Logs.List(ctx, jobID, params) (*SinglePage[SuperSlurperJobLogListResponse], error)`

**get** `/accounts/{account_id}/slurper/jobs/{job_id}/logs`

Gets log entries for an R2 Super Slurper migration job, showing migration status changes, errors, etc.

### Parameters

- `jobID string`

- `params SuperSlurperJobLogListParams`

  - `AccountID param.Field[string]`

    Path param

  - `Limit param.Field[int64]`

    Query param

  - `Offset param.Field[int64]`

    Query param

### Returns

- `type SuperSlurperJobLogListResponse struct{…}`

  - `CreatedAt string`

  - `Job string`

  - `LogType SuperSlurperJobLogListResponseLogType`

    - `const SuperSlurperJobLogListResponseLogTypeMigrationStart SuperSlurperJobLogListResponseLogType = "migrationStart"`

    - `const SuperSlurperJobLogListResponseLogTypeMigrationComplete SuperSlurperJobLogListResponseLogType = "migrationComplete"`

    - `const SuperSlurperJobLogListResponseLogTypeMigrationAbort SuperSlurperJobLogListResponseLogType = "migrationAbort"`

    - `const SuperSlurperJobLogListResponseLogTypeMigrationError SuperSlurperJobLogListResponseLogType = "migrationError"`

    - `const SuperSlurperJobLogListResponseLogTypeMigrationPause SuperSlurperJobLogListResponseLogType = "migrationPause"`

    - `const SuperSlurperJobLogListResponseLogTypeMigrationResume SuperSlurperJobLogListResponseLogType = "migrationResume"`

    - `const SuperSlurperJobLogListResponseLogTypeMigrationErrorFailedContinuation SuperSlurperJobLogListResponseLogType = "migrationErrorFailedContinuation"`

    - `const SuperSlurperJobLogListResponseLogTypeImportErrorRetryExhaustion SuperSlurperJobLogListResponseLogType = "importErrorRetryExhaustion"`

    - `const SuperSlurperJobLogListResponseLogTypeImportSkippedStorageClass SuperSlurperJobLogListResponseLogType = "importSkippedStorageClass"`

    - `const SuperSlurperJobLogListResponseLogTypeImportSkippedOversized SuperSlurperJobLogListResponseLogType = "importSkippedOversized"`

    - `const SuperSlurperJobLogListResponseLogTypeImportSkippedEmptyObject SuperSlurperJobLogListResponseLogType = "importSkippedEmptyObject"`

    - `const SuperSlurperJobLogListResponseLogTypeImportSkippedUnsupportedContentType SuperSlurperJobLogListResponseLogType = "importSkippedUnsupportedContentType"`

    - `const SuperSlurperJobLogListResponseLogTypeImportSkippedExcludedContentType SuperSlurperJobLogListResponseLogType = "importSkippedExcludedContentType"`

    - `const SuperSlurperJobLogListResponseLogTypeImportSkippedInvalidMedia SuperSlurperJobLogListResponseLogType = "importSkippedInvalidMedia"`

    - `const SuperSlurperJobLogListResponseLogTypeImportSkippedRequiresRetrieval SuperSlurperJobLogListResponseLogType = "importSkippedRequiresRetrieval"`

  - `Message string`

  - `ObjectKey string`

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  page, err := client.R2.SuperSlurper.Jobs.Logs.List(
    context.TODO(),
    "job_id",
    r2.SuperSlurperJobLogListParams{
      AccountID: cloudflare.F("account_id"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", page)
}
```

#### Response

```json
{
  "errors": [
    {
      "code": 7003,
      "message": "No route for the URI",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    "string"
  ],
  "result": [
    {
      "createdAt": "createdAt",
      "job": "job",
      "logType": "migrationStart",
      "message": "message",
      "objectKey": "objectKey"
    }
  ],
  "success": true
}
```

# Connectivity Precheck

## Check source connectivity

`client.R2.SuperSlurper.ConnectivityPrecheck.Source(ctx, params) (*SuperSlurperConnectivityPrecheckSourceResponse, error)`

**put** `/accounts/{account_id}/slurper/source/connectivity-precheck`

Check whether tokens are valid against the source bucket

### Parameters

- `params SuperSlurperConnectivityPrecheckSourceParams`

  - `AccountID param.Field[string]`

    Path param

  - `Bucket param.Field[string]`

    Body param

  - `Secret param.Field[SuperSlurperConnectivityPrecheckSourceParamsR2SlurperS3SourceSchemaSecret]`

    Body param

    - `AccessKeyID string`

    - `SecretAccessKey string`

  - `Vendor param.Field[SuperSlurperConnectivityPrecheckSourceParamsR2SlurperS3SourceSchemaVendor]`

    Body param

    - `const SuperSlurperConnectivityPrecheckSourceParamsR2SlurperS3SourceSchemaVendorS3 SuperSlurperConnectivityPrecheckSourceParamsR2SlurperS3SourceSchemaVendor = "s3"`

  - `Endpoint param.Field[string]`

    Body param

  - `Keys param.Field[[]string]`

    Body param

  - `PathPrefix param.Field[string]`

    Body param

  - `Region param.Field[string]`

    Body param

### Returns

- `type SuperSlurperConnectivityPrecheckSourceResponse struct{…}`

  - `ConnectivityStatus SuperSlurperConnectivityPrecheckSourceResponseConnectivityStatus`

    - `const SuperSlurperConnectivityPrecheckSourceResponseConnectivityStatusSuccess SuperSlurperConnectivityPrecheckSourceResponseConnectivityStatus = "success"`

    - `const SuperSlurperConnectivityPrecheckSourceResponseConnectivityStatusError SuperSlurperConnectivityPrecheckSourceResponseConnectivityStatus = "error"`

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  response, err := client.R2.SuperSlurper.ConnectivityPrecheck.Source(context.TODO(), r2.SuperSlurperConnectivityPrecheckSourceParams{
    AccountID: cloudflare.F("account_id"),
    Body: r2.SuperSlurperConnectivityPrecheckSourceParamsBodyR2SlurperS3SourceSchema{
      Bucket: cloudflare.F("bucket"),
      Secret: cloudflare.F(r2.SuperSlurperConnectivityPrecheckSourceParamsBodyR2SlurperS3SourceSchemaSecret{
        AccessKeyID: cloudflare.F("accessKeyId"),
        SecretAccessKey: cloudflare.F("secretAccessKey"),
      }),
      Vendor: cloudflare.F(r2.SuperSlurperConnectivityPrecheckSourceParamsBodyR2SlurperS3SourceSchemaVendorS3),
    },
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", response.ConnectivityStatus)
}
```

#### Response

```json
{
  "errors": [
    {
      "code": 7003,
      "message": "No route for the URI",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    "string"
  ],
  "result": {
    "connectivityStatus": "success"
  },
  "success": true
}
```

## Check target connectivity

`client.R2.SuperSlurper.ConnectivityPrecheck.Target(ctx, params) (*SuperSlurperConnectivityPrecheckTargetResponse, error)`

**put** `/accounts/{account_id}/slurper/target/connectivity-precheck`

Check whether tokens are valid against the target bucket

### Parameters

- `params SuperSlurperConnectivityPrecheckTargetParams`

  - `AccountID param.Field[string]`

    Path param

  - `Bucket param.Field[string]`

    Body param

  - `Secret param.Field[SuperSlurperConnectivityPrecheckTargetParamsSecret]`

    Body param

    - `AccessKeyID string`

    - `SecretAccessKey string`

  - `Vendor param.Field[Provider]`

    Body param

  - `Jurisdiction param.Field[SuperSlurperConnectivityPrecheckTargetParamsJurisdiction]`

    Body param

    - `const SuperSlurperConnectivityPrecheckTargetParamsJurisdictionDefault SuperSlurperConnectivityPrecheckTargetParamsJurisdiction = "default"`

    - `const SuperSlurperConnectivityPrecheckTargetParamsJurisdictionEu SuperSlurperConnectivityPrecheckTargetParamsJurisdiction = "eu"`

    - `const SuperSlurperConnectivityPrecheckTargetParamsJurisdictionFedramp SuperSlurperConnectivityPrecheckTargetParamsJurisdiction = "fedramp"`

### Returns

- `type SuperSlurperConnectivityPrecheckTargetResponse struct{…}`

  - `ConnectivityStatus SuperSlurperConnectivityPrecheckTargetResponseConnectivityStatus`

    - `const SuperSlurperConnectivityPrecheckTargetResponseConnectivityStatusSuccess SuperSlurperConnectivityPrecheckTargetResponseConnectivityStatus = "success"`

    - `const SuperSlurperConnectivityPrecheckTargetResponseConnectivityStatusError SuperSlurperConnectivityPrecheckTargetResponseConnectivityStatus = "error"`

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  response, err := client.R2.SuperSlurper.ConnectivityPrecheck.Target(context.TODO(), r2.SuperSlurperConnectivityPrecheckTargetParams{
    AccountID: cloudflare.F("account_id"),
    Bucket: cloudflare.F("bucket"),
    Secret: cloudflare.F(r2.SuperSlurperConnectivityPrecheckTargetParamsSecret{
      AccessKeyID: cloudflare.F("accessKeyId"),
      SecretAccessKey: cloudflare.F("secretAccessKey"),
    }),
    Vendor: cloudflare.F(r2.ProviderR2),
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", response.ConnectivityStatus)
}
```

#### Response

```json
{
  "errors": [
    {
      "code": 7003,
      "message": "No route for the URI",
      "documentation_url": "documentation_url",
      "source": {
        "pointer": "pointer"
      }
    }
  ],
  "messages": [
    "string"
  ],
  "result": {
    "connectivityStatus": "success"
  },
  "success": true
}
```