# Connectivity

# Directory

# Services

## List Workers VPC connectivity services

`client.Connectivity.Directory.Services.List(ctx, params) (*V4PagePaginationArray[DirectoryServiceListResponse], error)`

**get** `/accounts/{account_id}/connectivity/directory/services`

List Workers VPC connectivity services

### Parameters

- `params DirectoryServiceListParams`

  - `AccountID param.Field[string]`

    Path param: Account identifier

  - `Page param.Field[int64]`

    Query param: Current page in the response

  - `PerPage param.Field[int64]`

    Query param: Max amount of entries returned per page

  - `Type param.Field[DirectoryServiceListParamsType]`

    Query param

    - `const DirectoryServiceListParamsTypeHTTP DirectoryServiceListParamsType = "http"`

### Returns

- `type DirectoryServiceListResponse struct{…}`

  - `Host DirectoryServiceListResponseHost`

    - `type DirectoryServiceListResponseHostInfraIPv4Host struct{…}`

      - `IPV4 string`

      - `Network DirectoryServiceListResponseHostInfraIPv4HostNetwork`

        - `TunnelID string`

    - `type DirectoryServiceListResponseHostInfraIPv6Host struct{…}`

      - `IPV6 string`

      - `Network DirectoryServiceListResponseHostInfraIPv6HostNetwork`

        - `TunnelID string`

    - `type DirectoryServiceListResponseHostInfraDualStackHost struct{…}`

      - `IPV4 string`

      - `IPV6 string`

      - `Network DirectoryServiceListResponseHostInfraDualStackHostNetwork`

        - `TunnelID string`

    - `type DirectoryServiceListResponseHostInfraHostnameHost struct{…}`

      - `Hostname string`

      - `ResolverNetwork DirectoryServiceListResponseHostInfraHostnameHostResolverNetwork`

        - `TunnelID string`

        - `ResolverIPs []string`

  - `Name string`

  - `Type DirectoryServiceListResponseType`

    - `const DirectoryServiceListResponseTypeHTTP DirectoryServiceListResponseType = "http"`

  - `CreatedAt Time`

  - `HTTPPort int64`

  - `HTTPSPort int64`

  - `ServiceID string`

  - `UpdatedAt Time`

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  page, err := client.Connectivity.Directory.Services.List(context.TODO(), connectivity.DirectoryServiceListParams{
    AccountID: 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"
      }
    }
  ],
  "success": true,
  "result": [
    {
      "host": {
        "ipv4": "10.0.0.1",
        "network": {
          "tunnel_id": "0191dce4-9ab4-7fce-b660-8e5dec5172da"
        }
      },
      "name": "web-app",
      "type": "http",
      "created_at": "2024-01-15T09:30:00Z",
      "http_port": 8080,
      "https_port": 8443,
      "service_id": "550e8400-e29b-41d4-a716-446655440000",
      "updated_at": "2024-01-15T10:45:00Z"
    }
  ],
  "result_info": {
    "count": 1,
    "page": 1,
    "per_page": 20,
    "total_count": 2000,
    "total_pages": 100
  }
}
```

## Create Workers VPC connectivity service

`client.Connectivity.Directory.Services.New(ctx, params) (*DirectoryServiceNewResponse, error)`

**post** `/accounts/{account_id}/connectivity/directory/services`

Create Workers VPC connectivity service

### Parameters

- `params DirectoryServiceNewParams`

  - `AccountID param.Field[string]`

    Path param: Account identifier

  - `Host param.Field[DirectoryServiceNewParamsHost]`

    Body param

    - `type DirectoryServiceNewParamsHostInfraIPv4Host struct{…}`

      - `IPV4 string`

      - `Network DirectoryServiceNewParamsHostInfraIPv4HostNetwork`

        - `TunnelID string`

    - `type DirectoryServiceNewParamsHostInfraIPv6Host struct{…}`

      - `IPV6 string`

      - `Network DirectoryServiceNewParamsHostInfraIPv6HostNetwork`

        - `TunnelID string`

    - `type DirectoryServiceNewParamsHostInfraDualStackHost struct{…}`

      - `IPV4 string`

      - `IPV6 string`

      - `Network DirectoryServiceNewParamsHostInfraDualStackHostNetwork`

        - `TunnelID string`

    - `type DirectoryServiceNewParamsHostInfraHostnameHost struct{…}`

      - `Hostname string`

      - `ResolverNetwork DirectoryServiceNewParamsHostInfraHostnameHostResolverNetwork`

        - `TunnelID string`

        - `ResolverIPs []string`

  - `Name param.Field[string]`

    Body param

  - `Type param.Field[DirectoryServiceNewParamsType]`

    Body param

    - `const DirectoryServiceNewParamsTypeHTTP DirectoryServiceNewParamsType = "http"`

  - `HTTPPort param.Field[int64]`

    Body param

  - `HTTPSPort param.Field[int64]`

    Body param

### Returns

- `type DirectoryServiceNewResponse struct{…}`

  - `Host DirectoryServiceNewResponseHost`

    - `type DirectoryServiceNewResponseHostInfraIPv4Host struct{…}`

      - `IPV4 string`

      - `Network DirectoryServiceNewResponseHostInfraIPv4HostNetwork`

        - `TunnelID string`

    - `type DirectoryServiceNewResponseHostInfraIPv6Host struct{…}`

      - `IPV6 string`

      - `Network DirectoryServiceNewResponseHostInfraIPv6HostNetwork`

        - `TunnelID string`

    - `type DirectoryServiceNewResponseHostInfraDualStackHost struct{…}`

      - `IPV4 string`

      - `IPV6 string`

      - `Network DirectoryServiceNewResponseHostInfraDualStackHostNetwork`

        - `TunnelID string`

    - `type DirectoryServiceNewResponseHostInfraHostnameHost struct{…}`

      - `Hostname string`

      - `ResolverNetwork DirectoryServiceNewResponseHostInfraHostnameHostResolverNetwork`

        - `TunnelID string`

        - `ResolverIPs []string`

  - `Name string`

  - `Type DirectoryServiceNewResponseType`

    - `const DirectoryServiceNewResponseTypeHTTP DirectoryServiceNewResponseType = "http"`

  - `CreatedAt Time`

  - `HTTPPort int64`

  - `HTTPSPort int64`

  - `ServiceID string`

  - `UpdatedAt Time`

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  service, err := client.Connectivity.Directory.Services.New(context.TODO(), connectivity.DirectoryServiceNewParams{
    AccountID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
    Host: cloudflare.F[connectivity.DirectoryServiceNewParamsHostUnion](connectivity.DirectoryServiceNewParamsHostInfraHostnameHost{
      Hostname: cloudflare.F("api.example.com"),
      ResolverNetwork: cloudflare.F(connectivity.DirectoryServiceNewParamsHostInfraHostnameHostResolverNetwork{
        TunnelID: cloudflare.F("0191dce4-9ab4-7fce-b660-8e5dec5172da"),
      }),
    }),
    Name: cloudflare.F("web-server"),
    Type: cloudflare.F(connectivity.DirectoryServiceNewParamsTypeHTTP),
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", service.ServiceID)
}
```

#### Response

```json
{
  "errors": [],
  "messages": [],
  "result": {
    "created_at": "2024-01-15T09:30:00Z",
    "host": {
      "hostname": "api.example.com",
      "resolver_network": {
        "tunnel_id": "0191dce4-9ab4-7fce-b660-8e5dec5172da"
      }
    },
    "name": "web-server",
    "service_id": "550e8400-e29b-41d4-a716-446655440000",
    "type": "http",
    "updated_at": "2024-01-15T09:30:00Z"
  },
  "success": true
}
```

## Get Workers VPC connectivity service

`client.Connectivity.Directory.Services.Get(ctx, serviceID, query) (*DirectoryServiceGetResponse, error)`

**get** `/accounts/{account_id}/connectivity/directory/services/{service_id}`

Get Workers VPC connectivity service

### Parameters

- `serviceID string`

- `query DirectoryServiceGetParams`

  - `AccountID param.Field[string]`

### Returns

- `type DirectoryServiceGetResponse struct{…}`

  - `Host DirectoryServiceGetResponseHost`

    - `type DirectoryServiceGetResponseHostInfraIPv4Host struct{…}`

      - `IPV4 string`

      - `Network DirectoryServiceGetResponseHostInfraIPv4HostNetwork`

        - `TunnelID string`

    - `type DirectoryServiceGetResponseHostInfraIPv6Host struct{…}`

      - `IPV6 string`

      - `Network DirectoryServiceGetResponseHostInfraIPv6HostNetwork`

        - `TunnelID string`

    - `type DirectoryServiceGetResponseHostInfraDualStackHost struct{…}`

      - `IPV4 string`

      - `IPV6 string`

      - `Network DirectoryServiceGetResponseHostInfraDualStackHostNetwork`

        - `TunnelID string`

    - `type DirectoryServiceGetResponseHostInfraHostnameHost struct{…}`

      - `Hostname string`

      - `ResolverNetwork DirectoryServiceGetResponseHostInfraHostnameHostResolverNetwork`

        - `TunnelID string`

        - `ResolverIPs []string`

  - `Name string`

  - `Type DirectoryServiceGetResponseType`

    - `const DirectoryServiceGetResponseTypeHTTP DirectoryServiceGetResponseType = "http"`

  - `CreatedAt Time`

  - `HTTPPort int64`

  - `HTTPSPort int64`

  - `ServiceID string`

  - `UpdatedAt Time`

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  service, err := client.Connectivity.Directory.Services.Get(
    context.TODO(),
    "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
    connectivity.DirectoryServiceGetParams{
      AccountID: cloudflare.F("account_id"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", service.ServiceID)
}
```

#### 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"
      }
    }
  ],
  "success": true,
  "result": {
    "host": {
      "ipv4": "10.0.0.1",
      "network": {
        "tunnel_id": "0191dce4-9ab4-7fce-b660-8e5dec5172da"
      }
    },
    "name": "web-app",
    "type": "http",
    "created_at": "2024-01-15T09:30:00Z",
    "http_port": 8080,
    "https_port": 8443,
    "service_id": "550e8400-e29b-41d4-a716-446655440000",
    "updated_at": "2024-01-15T10:45:00Z"
  }
}
```

## Update Workers VPC connectivity service

`client.Connectivity.Directory.Services.Update(ctx, serviceID, params) (*DirectoryServiceUpdateResponse, error)`

**put** `/accounts/{account_id}/connectivity/directory/services/{service_id}`

Update Workers VPC connectivity service

### Parameters

- `serviceID string`

- `params DirectoryServiceUpdateParams`

  - `AccountID param.Field[string]`

    Path param

  - `Host param.Field[DirectoryServiceUpdateParamsHost]`

    Body param

    - `type DirectoryServiceUpdateParamsHostInfraIPv4Host struct{…}`

      - `IPV4 string`

      - `Network DirectoryServiceUpdateParamsHostInfraIPv4HostNetwork`

        - `TunnelID string`

    - `type DirectoryServiceUpdateParamsHostInfraIPv6Host struct{…}`

      - `IPV6 string`

      - `Network DirectoryServiceUpdateParamsHostInfraIPv6HostNetwork`

        - `TunnelID string`

    - `type DirectoryServiceUpdateParamsHostInfraDualStackHost struct{…}`

      - `IPV4 string`

      - `IPV6 string`

      - `Network DirectoryServiceUpdateParamsHostInfraDualStackHostNetwork`

        - `TunnelID string`

    - `type DirectoryServiceUpdateParamsHostInfraHostnameHost struct{…}`

      - `Hostname string`

      - `ResolverNetwork DirectoryServiceUpdateParamsHostInfraHostnameHostResolverNetwork`

        - `TunnelID string`

        - `ResolverIPs []string`

  - `Name param.Field[string]`

    Body param

  - `Type param.Field[DirectoryServiceUpdateParamsType]`

    Body param

    - `const DirectoryServiceUpdateParamsTypeHTTP DirectoryServiceUpdateParamsType = "http"`

  - `HTTPPort param.Field[int64]`

    Body param

  - `HTTPSPort param.Field[int64]`

    Body param

### Returns

- `type DirectoryServiceUpdateResponse struct{…}`

  - `Host DirectoryServiceUpdateResponseHost`

    - `type DirectoryServiceUpdateResponseHostInfraIPv4Host struct{…}`

      - `IPV4 string`

      - `Network DirectoryServiceUpdateResponseHostInfraIPv4HostNetwork`

        - `TunnelID string`

    - `type DirectoryServiceUpdateResponseHostInfraIPv6Host struct{…}`

      - `IPV6 string`

      - `Network DirectoryServiceUpdateResponseHostInfraIPv6HostNetwork`

        - `TunnelID string`

    - `type DirectoryServiceUpdateResponseHostInfraDualStackHost struct{…}`

      - `IPV4 string`

      - `IPV6 string`

      - `Network DirectoryServiceUpdateResponseHostInfraDualStackHostNetwork`

        - `TunnelID string`

    - `type DirectoryServiceUpdateResponseHostInfraHostnameHost struct{…}`

      - `Hostname string`

      - `ResolverNetwork DirectoryServiceUpdateResponseHostInfraHostnameHostResolverNetwork`

        - `TunnelID string`

        - `ResolverIPs []string`

  - `Name string`

  - `Type DirectoryServiceUpdateResponseType`

    - `const DirectoryServiceUpdateResponseTypeHTTP DirectoryServiceUpdateResponseType = "http"`

  - `CreatedAt Time`

  - `HTTPPort int64`

  - `HTTPSPort int64`

  - `ServiceID string`

  - `UpdatedAt Time`

### Example

```go
package main

import (
  "context"
  "fmt"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  service, err := client.Connectivity.Directory.Services.Update(
    context.TODO(),
    "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
    connectivity.DirectoryServiceUpdateParams{
      AccountID: cloudflare.F("account_id"),
      Host: cloudflare.F[connectivity.DirectoryServiceUpdateParamsHostUnion](connectivity.DirectoryServiceUpdateParamsHostInfraIPv4Host{
        IPV4: cloudflare.F("10.0.0.1"),
        Network: cloudflare.F(connectivity.DirectoryServiceUpdateParamsHostInfraIPv4HostNetwork{
          TunnelID: cloudflare.F("0191dce4-9ab4-7fce-b660-8e5dec5172da"),
        }),
      }),
      Name: cloudflare.F("web-app"),
      Type: cloudflare.F(connectivity.DirectoryServiceUpdateParamsTypeHTTP),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", service.ServiceID)
}
```

#### 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"
      }
    }
  ],
  "success": true,
  "result": {
    "host": {
      "ipv4": "10.0.0.1",
      "network": {
        "tunnel_id": "0191dce4-9ab4-7fce-b660-8e5dec5172da"
      }
    },
    "name": "web-app",
    "type": "http",
    "created_at": "2024-01-15T09:30:00Z",
    "http_port": 8080,
    "https_port": 8443,
    "service_id": "550e8400-e29b-41d4-a716-446655440000",
    "updated_at": "2024-01-15T10:45:00Z"
  }
}
```

## Delete Workers VPC connectivity service

`client.Connectivity.Directory.Services.Delete(ctx, serviceID, body) error`

**delete** `/accounts/{account_id}/connectivity/directory/services/{service_id}`

Delete Workers VPC connectivity service

### Parameters

- `serviceID string`

- `body DirectoryServiceDeleteParams`

  - `AccountID param.Field[string]`

### Example

```go
package main

import (
  "context"

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

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  err := client.Connectivity.Directory.Services.Delete(
    context.TODO(),
    "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
    connectivity.DirectoryServiceDeleteParams{
      AccountID: cloudflare.F("account_id"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
}
```