Zscaler Go SDK

https://github.com/zscaler/zscaler-sdk-go
Admin
The Zscaler Go SDK is an official Go client library for interacting with Zscaler Zero Trust Exchange...
Tokens:42,813
Snippets:446
Trust Score:8.2
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Initialize Zscaler Client

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/README.md

Example of configuring the client with credentials, vanity domain, and custom retry/timeout settings.

```go
import (
 "fmt"
 "context"
 "github.com/zscaler/zscaler-sdk-go/v3/zscaler"
)

func main() {
  config, err := zscaler.NewConfiguration(
    zscaler.WithClientID(""),
    zscaler.WithClientSecret(""),
    zscaler.WithVanityDomain("acme")
    zscaler.WithRequestTimeout(45),
    zscaler.WithRateLimitMaxRetries(3),
    zscaler.WithRateLimitRemainingThreshold(5),
  )
  if err != nil {
    fmt.Printf("Error: %v\n", err)
  }
  client := zscaler.NewOneAPIClient(config)
}
```

--------------------------------

### Fetch All Users in ZIA

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/README.md

Example usage of the GetAllUsers function to retrieve and print all users.

```go
func main() {
ctx := context.Background()

// Fetch all users
allUsers, err := GetAllUsers(ctx, service)
if err != nil {
    log.Fatalf("Error fetching users: %v", err)
}

fmt.Printf("Fetched %d users\n", len(allUsers))
for _, user := range allUsers {
    fmt.Printf("User: %+v\n", user)
  }
}
```

--------------------------------

### Get a SCIM Group

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/README.md

Retrieves details for a specific SCIM group by its unique identifier.

```go
import (
 "context"
 "fmt"
 "log"

 "github.com/zscaler/zscaler-sdk-go/v3/zscaler"
 "github.com/zscaler/zscaler-sdk-go/v3/zscaler/zpa/services/scimgroup"
)

func main() {
 config, err := zscaler.NewConfiguration(
  zscaler.WithClientID(""),
  zscaler.WithClientSecret(""),
  zscaler.WithVanityDomain("acme"),
  zscaler.WithZPACustomerID("12354547545"),
 )
 if err != nil {
  fmt.Printf("Error: %v\n", err)
 }

 service, err := zscaler.NewOneAPIClient(config)
 if err != nil {
  log.Fatalf("Error creating OneAPI client: %v", err)
 }

 ctx := context.Background()
 groupID := "1405240"

 allGroups, _, err := scimgroup.Get(ctx, service, groupID)
 if err != nil {
  log.Fatalf("Error retrieving scim group: %v", err)
 }
 fmt.Printf("Successfully retrieved SCIM group: %+v\n", allGroups)
}
```

--------------------------------

### Initialize ZTW Client

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/README.md

Initializes a ZTW client using environment variables for credentials and demonstrates listing locations.

```go
import (
	"context"
	"fmt"
	"log"

	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/ztw"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/ztw/services"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/ztw/services/locationmanagement/location"
)

func main() {
	username := os.Getenv("ZTC_USERNAME")
	password := os.Getenv("ZTC_PASSWORD")
	apiKey   := os.Getenv("ZTC_API_KEY")
	ztwCloud := os.Getenv("ZTC_CLOUD")

  ztwCfg, err := ztw.NewConfiguration(
		ztw.WithZtwUsername(username),
		ztw.WithZtwPassword(password),
		ztw.WithZtwAPIKey(apiKey),
		ztw.WithZtwCloud(ztwCloud),
		ztw.WithDebug(true),
	)
	if err != nil {
		log.Fatalf("Error creating ZTW configuration: %v", err)
	}

	service, err := zscaler.NewLegacyZtwClient(ztwCfg)
	if err != nil {
		log.Fatalf("Error creating ZTW client: %v", err)
	}

	ctx := context.TODO()
	locations, err := location.GetAll(ctx, service)
	if err != nil {
		log.Fatalf("Error listing locations: %v", err)
	}

	fmt.Printf("Locations: %+v\n", locations)
	for index, location := range locations {
		fmt.Printf("Location %d: %+v\n", index, location)
	}
}
```

--------------------------------

### JMESPath Expression Examples

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/CLAUDE.md

Common JMESPath expressions for filtering, projecting, and aggregating data.

```go
// Filter: keep only active Windows devices
"[?osType=='Windows' && status=='active']"

// Projection: extract names only (returns []map, not []T)
"[*].{name: name, id: id}"

// Combined filter + field extraction
"[?enabled==`true`].name"

// Count
"length([?status=='inactive'])"
```

--------------------------------

### Initialize OneAPI Client with Private Key

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/README.md

Construct a client instance using Zidentity ClientID, a path to a private key file, and VanityDomain.

```go
import (
 "fmt"
 "context"
 "github.com/zscaler/zscaler-sdk-go/v3/zscaler"
)

func main() {
  config, err := zscaler.NewConfiguration(
    zscaler.WithClientID(""),
    zscaler.WithPrivateKey("private_key.pem"),
    zscaler.WithVanityDomain("acme")
  )
  if err != nil {
    fmt.Printf("Error: %v\n", err)
  }
  service, err := zscaler.NewOneAPIClient(config)
}
```

--------------------------------

### Initialize ZCC Client

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/README.md

Initializes a ZCC client using environment variables for credentials and demonstrates listing devices.

```go
import (
 "context"
 "log"

 "github.com/zscaler/zscaler-sdk-go/v3/zscaler"
 "github.com/zscaler/zscaler-sdk-go/v3/zscaler/zcc"
 "github.com/zscaler/zscaler-sdk-go/v3/zscaler/zcc/services/devices"
)

func main() {
	clientID := os.Getenv("ZCC_CLIENT_ID")
	clientSecret := os.Getenv("ZCC_CLIENT_SECRET")
	cloud := os.Getenv("ZCC_CLOUD")

 zccCfg, err := zcc.NewConfiguration(
  zcc.WithZCCClientID(clientID),
  zcc.WithZCCClientSecret(clientSecret),
  zcc.WithZCCCloud(cloud),
 )
	if err != nil {
		log.Fatalf("Error creating ZCC configuration: %v", err)
	}

        // Initialize ZCC client
        service, err := zscaler.NewLegacyZccClient(zccCfg)
	if err != nil {
		log.Fatalf("Error creating ZCC client: %v", err)
	}

 ctx := context.TODO()
 username := "adam.ashcroft@acme.com"
 osType := "3"
 listDevices, err := devices.GetAll(ctx, service, username, osType)
 if err != nil {
  log.Fatalf("Error listing devices: %v", err)
 }

 for _, device := range listDevices {
  log.Printf("Device: %+v\n", device)
 }
}
```

--------------------------------

### Initialize Zscaler Client

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/CLAUDE.md

Configure and instantiate a new Zscaler client using the configuration builder pattern.

```go
config, err := zscaler.NewConfiguration(
    zscaler.WithClientID("client-id"),
    zscaler.WithClientSecret("secret"),
    zscaler.WithVanityDomain("acme"),
    zscaler.WithCloud("zscloud"),
    zscaler.WithCache(true),
    zscaler.WithCacheTtl(10 * time.Minute),
)
service, err := zscaler.NewOneAPIClient(config)
```

--------------------------------

### GET /ziam/admin/api/v1/users/{id}/groups

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/examples/zidentity/users/get_user_groups.md

Retrieves a list of groups associated with a specific user, including pagination support.

```APIDOC
## GET /ziam/admin/api/v1/users/{id}/groups

### Description
Retrieves the groups associated with a specific user. The response is paginated.

### Method
GET

### Endpoint
/ziam/admin/api/v1/users/{id}/groups

### Parameters
#### Path Parameters
- **id** (string) - Required - The user ID of the individual whose groups details are to be retrieved

#### Query Parameters
- **offset** (integer) - Optional - The starting point for pagination, with the number of records that can be skipped before fetching results (minimum: 0)
- **limit** (integer) - Optional - The maximum number of records to return per request (minimum: 0, maximum: 1000)

### Response
#### Success Response (200)
- **results_total** (integer) - Total number of results
- **pageOffset** (integer) - Current page offset
- **pageSize** (integer) - Number of records per page
- **next_link** (string) - Link to the next page
- **prev_link** (string) - Link to the previous page
- **records** (array) - List of group objects

#### Response Example
{
  "results_total": 0,
  "pageOffset": 0,
  "pageSize": 0,
  "next_link": "string",
  "prev_link": "string",
  "records": [
    {
      "name": "string",
      "description": "string",
      "id": "string",
      "source": "UI",
      "idp": {
        "id": "string",
        "name": "string",
        "displayName": "string"
      },
      "isDynamicGroup": true,
      "adminEntitlementEnabled": true,
      "serviceEntitlementEnabled": true
    }
  ]
}
```

--------------------------------

### Initialize OneAPI Client with Client Secret

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/README.md

Construct a client instance using Zidentity ClientID, ClientSecret, and VanityDomain.

```go
import (
 "fmt"
 "context"
 "github.com/zscaler/zscaler-sdk-go/v3/zscaler"
)

func main() {
  config, err := zscaler.NewConfiguration(
    zscaler.WithClientID(""),
    zscaler.WithClientSecret(""),
    zscaler.WithVanityDomain("acme")
  )
  if err != nil {
    fmt.Printf("Error: %v\n", err)
  }
  service, err := zscaler.NewOneAPIClient(config)
}
```

--------------------------------

### ZIA Service Helper Patterns

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/CLAUDE.md

Examples demonstrating the use of ZIA client helpers for common operations like CSV export, CSV import, and validation endpoints where request and response types differ.

```go
// ZIA — CSV export (GET, no body; response is CSV). Request must use
// application/json (ReadRaw with ""), not text/csv, or OneAPI returns 415.
func ExportFoo(ctx context.Context, service *zscaler.Service) ([]byte, error) {
    return service.Client.ReadRaw(ctx, fooExportEndpoint, "")
}

// ZIA — CSV import (POST body is CSV; Content-Type must be text/csv)
func ImportFoo(ctx context.Context, service *zscaler.Service, csv []byte) (*http.Response, error) {
    _, resp, err := service.Client.CreateWithRawPayloadAndContentType(ctx, fooImportEndpoint, csv, "text/csv")
    return resp, err
}

// ZIA — validate / dry-run (request and response types differ)
func ValidateFoo(ctx context.Context, service *zscaler.Service, body string) (*FooValidation, error) {
    var v FooValidation
    err := service.Client.CreateWithJSONResponse(ctx, fooValidateEndpoint, FooValidateRequest{Body: body}, &v)
    return &v, err
}
```

--------------------------------

### Manage ZIA Locations with Go SDK

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/examples/zia/zia_location_management/README.md

Demonstrates initializing the ZIA client and performing create, update, and delete operations on location management resources.

```go
package main

import (
	"log"

	"github.com/zscaler/zscaler-sdk-go/v3/zia"
	"github.com/zscaler/zscaler-sdk-go/v3/zia/services/locationmanagement"
)

func main() {
	username := os.Getenv("ZIA_USERNAME")
	password := os.Getenv("ZIA_PASSWORD")
	apiKey := os.Getenv("ZIA_API_KEY")
	ziaCloud := os.Getenv("ZIA_CLOUD")

	cli, err := zia.NewClient(username, password, apiKey, ziaCloud, "userAgent")
	if err != nil {
		log.Printf("[ERROR] creating client failed: %v\n", err)
		return
	}

	locationManagementService := locationmanagement.New(cli)
	locationManagement := locationmanagement.Locations{
		Name:              "Example location managment",
		Description:       "Example location managment",
		Country:           "UNITED_STATES",
		TZ:                "UNITED_STATES_AMERICA_LOS_ANGELES",
		AuthRequired:      true,
		IdleTimeInMinutes: 720,
		DisplayTimeUnit:   "HOUR",
		SurrogateIP:       true,
		XFFForwardEnabled: true,
		OFWEnabled:        true,
		IPSControl:        true,
		IPAddresses:       []string{"1.1.1.1"},
	}
	// Create new location managment
	createLocationManagement, err := locationManagementService.Create(&locationManagement)
	if err != nil {
		log.Printf("[ERROR] creating location managment failed: %v\n", err)
		return
	}
	// Update location managment
	createLocationManagement.Description = "New description"
	_, _, err = locationManagementService.Update(createLocationManagement.ID, createLocationManagement)
	if err != nil {
		log.Printf("[ERROR] updating location managment failed: %v\n", err)
		return
	}
	// Delete location managment
	_, err = locationManagementService.Delete(createLocationManagement.ID)
	if err != nil {
		log.Printf("[ERROR] deleting location managment failed: %v\n", err)
		return
	}
}
```

--------------------------------

### Manage ZPA Server Groups and App Connector Groups

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/examples/zpa/zpa_server_groups/README.md

Demonstrates initializing the ZPA client, creating an app connector group, and performing CRUD operations on a server group.

```go
package main

import (
	"log"

	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zpa"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zpa/services/appconnectorgroup"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zpa/services/servergroup"
)

func main() {
	zpa_client_id := os.Getenv("ZPA_CLIENT_ID")
	zpa_client_secret := os.Getenv("ZPA_CLIENT_SECRET")
	zpa_customer_id := os.Getenv("ZPA_CUSTOMER_ID")
	zpa_cloud := os.Getenv("ZPA_CLOUD")
	config, err := zpa.NewConfig(zpa_client_id, zpa_client_secret, zpa_customer_id, zpa_cloud, "userAgent")
	if err != nil {
		log.Printf("[ERROR] creating config failed: %v\n", err)
		return
	}
	zpaClient := zpa.NewClient(config)
	zpaServerGroupsService := servergroup.New(zpaClient)
	appConnectorGroupService := appconnectorgroup.New(zpaClient)
	appConnectorGroup := appconnectorgroup.AppConnectorGroup{
		Name:                   "Example app connector group",
		Description:            "Example  app connector group",
		Enabled:                true,
		CityCountry:            "California, US",
		CountryCode:            "US",
		Latitude:               "37.3382082",
		Longitude:              "-121.8863286",
		Location:               "San Jose, CA, USA",
		UpgradeDay:             "SUNDAY",
		UpgradeTimeInSecs:      "66600",
		OverrideVersionProfile: true,
		VersionProfileID:       "0",
		DNSQueryType:           "IPV4",
	}
	// Create new app connector group
	createdAppConnectorGroup, _, err := appConnectorGroupService.Create(appConnectorGroup)
	if err != nil {
		log.Printf("[ERROR] creating app connector group failed: %v\n", err)
		return
	}
	app := servergroup.ServerGroup{
		Name:             "Example server group",
		Description:      "Example server group",
		Enabled:          true,
		DynamicDiscovery: true,
		AppConnectorGroups: []servergroup.AppConnectorGroups{
			{
				ID: createdAppConnectorGroup.ID,
			},
		},
	}
	// Create new server group
	createdResource, _, err := zpaServerGroupsService.Create(&app)
	if err != nil {
		log.Printf("[ERROR] creating server group failed: %v\n", err)
		return
	}
	// Update server group
	createdResource.Description = "New description"
	_, err = zpaServerGroupsService.Update(createdResource.ID, createdResource)
	if err != nil {
		log.Printf("[ERROR] updating server group failed: %v\n", err)
		return
	}
	// Delete server group
	_, err = zpaServerGroupsService.Delete(createdResource.ID)
	if err != nil {
		log.Printf("[ERROR] deleting server group failed: %v\n", err)
		return
	}

	// Delete app connector group
	_, err = appConnectorGroupService.Delete(createdAppConnectorGroup.ID)
	if err != nil {
		log.Printf("[ERROR] deleting app connector group failed: %v\n", err)
		return
	}
}
```

--------------------------------

### Initialize ZPA SCIM Client

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/README.md

Initializes a ZPA SCIM client using environment variables and retrieves all groups.

```go
import (
 "context"
 "fmt"
 "log"

	"github.com/zscaler/zscaler-sdk-go/v3/zscaler"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zpa"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zpa/services/scim_api"
)

func main() {
	scimToken := os.Getenv("ZPA_SCIM_TOKEN")
	idpId := os.Getenv("ZPA_IDP_ID")
	scimCloud := os.Getenv("ZPA_SCIM_CLOUD")

	scimClient, err := zpa.NewScimConfig(
		zpa.WithScimToken(scimToken),
		zpa.WithIDPId(idpId),
		zpa.WithScimCloud(scimCloud),
	)
	if err != nil {
		log.Fatalf("failed to create SCIM client: %v", err)
	}

	service := zscaler.NewZPAScimService(scimClient)

  ctx := context.Background()
	groups, _, err := scim_api.GetAllGroups(ctx, service)
	if err != nil {
		log.Fatalf("Error retrieving SCIM groups: %v", err)
	}
	log.Printf("Retrieved SCIM Groups: %+v\n", groups)
}
```

--------------------------------

### Initialize ZIA Client

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/README.md

Configures a ZIA client using environment variables and retrieves rule labels. Requires the ZIA configuration to be initialized with valid credentials and cloud environment.

```go
import (
 "context"
 "fmt"
 "log"

 "github.com/zscaler/zscaler-sdk-go/v3/zscaler"
 "github.com/zscaler/zscaler-sdk-go/v3/zscaler/zia"
 "github.com/zscaler/zscaler-sdk-go/v3/zscaler/zia/services/rule_labels"
)

func main() {
	username := os.Getenv("ZIA_USERNAME")
	password := os.Getenv("ZIA_PASSWORD")
	apiKey   := os.Getenv("ZIA_API_KEY")
	ziaCloud := os.Getenv("ZIA_CLOUD")

	ziaCfg, err := zia.NewConfiguration(
		zia.WithZiaUsername(username),
		zia.WithZiaPassword(password),
		zia.WithZiaAPIKey(apiKey),
		zia.WithZiaCloud(ziaCloud),
		zia.WithDebug(true),
	)
	if err != nil {
		log.Fatalf("Error creating ZPA configuration: %v", err)
	}

	// Initialize ZPA client
	service, err := zscaler.NewLegacyZiaClient(ziaCfg)
	if err != nil {
		log.Fatalf("Error creating ZIA client: %v", err)
	}

 // Create a new context
 ctx := context.Background()
 labels, err := rule_labels.GetAll(ctx, service)
 if err != nil {
  log.Fatalf("Error Listing Labels: %v", err)
 }
 fmt.Printf("Labels: %+v\n", labels)
 for index, label := range labels {
  fmt.Printf("Label %d: %+v\n", index, label)
 }
}
```

--------------------------------

### Initialize ZIA SCIM Client

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/README.md

Initializes a ZIA SCIM client using environment variables and retrieves all users.

```go
import (
 "context"
 "fmt"
 "log"

	"github.com/zscaler/zscaler-sdk-go/v3/zscaler"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zia"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zia/services/scim_api"
)

func main() {
	scimToken := os.Getenv("ZIA_SCIM_API_TOKEN")
	scimCloud := os.Getenv("ZIA_SCIM_CLOUD")
	tenantID := os.Getenv("ZIA_SCIM_TENANT_ID")

	scimClient, err := zia.NewScimConfig(
		zia.WithScimToken(scimToken),
		zia.WithScimCloud(scimCloud),
		zia.WithTenantID(tenantID),
	)
	if err != nil {
		log.Fatalf("Failed to create SCIM client: %v", err)
	}

	service := zscaler.NewZIAScimService(scimClient) // This now properly initializes the Client

	ctx := context.Background()
	users, _, err := scim_api.GetAllUsers(ctx, service)
	if err != nil {
		log.Fatalf("Error retrieving SCIM users: %v", err)
	}
	log.Printf("Retrieved SCIM Users: %+v\n", users)
}
```

--------------------------------

### Initialize ZWA Client

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/README.md

Configures and initializes the ZWA client using API credentials retrieved from environment variables.

```go
import (
 "log"
 "github.com/zscaler/zscaler-sdk-go/v3/zscaler/zwa"
 "github.com/zscaler/zscaler-sdk-go/v3/zscaler/zwa/services"
 "github.com/zscaler/zscaler-sdk-go/v3/zscaler/zwa/services/dlp_incidents"
)

func main() {
	key_id := os.Getenv("ZWA_API_KEY_ID")
	key_secret := os.Getenv("ZWA_API_SECRET")
	cloud := os.Getenv("ZWA_CLOUD") // Optional

 zwaCfg, err := zwa.NewConfiguration(
	zwa.WithZWAAPIKeyID(key_id),
	zwa.WithZWAAPISecret(key_secret),
  zwa.WithZWACloud(cloud),
	zwa.WithDebug(true),
 )
 if err != nil {
  log.Fatalf("Error creating ZWA configuration: %v", err)
 }

 zwaClient, err := zwa.NewClient(zwaCfg)
 if err != nil {
  log.Fatalf("Error creating ZWA client: %v", err)
 }

 service := services.New(zwaClient)

	dlpIncidentID := "167867439920099003"

	evidence, _, err := dlp_incidents.GetDLPIncidentTriggers(ctx, service, dlpIncidentID)
	if err != nil {
		log.Fatalf("Error fetching DLP incident evidence: %v", err)
	}

	fmt.Printf("Evidence Details: %+v\n", evidence)
}
```

--------------------------------

### Define Default Pagination Options

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/docs/zidentity-pagination.md

Sets the initial configuration for page size and cursor usage.

```go
var DefaultPaginationOptions = PaginationOptions{
    DefaultPageSize: 100,
    MaxPageSize:     1000,
    UseCursor:       false,
}
```

--------------------------------

### Create a SCIM User

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/examples/zia_scim_api/users/create_user.md

Requires environment variables ZIA_SCIM_API_TOKEN, ZIA_SCIM_CLOUD, and ZIA_SCIM_TENANT_ID to be set for client authentication.

```go
package main

import (
	"context"
	"log"
	"os"

	"github.com/zscaler/zscaler-sdk-go/v3/zscaler"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zia"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zia/services/scim_api"
)

func main() {
	scimToken := os.Getenv("ZIA_SCIM_API_TOKEN")
	scimCloud := os.Getenv("ZIA_SCIM_CLOUD")
	tenantID := os.Getenv("ZIA_SCIM_TENANT_ID")

	scimClient, err := zia.NewScimConfig(
		zia.WithScimToken(scimToken),
		zia.WithScimCloud(scimCloud),
		zia.WithTenantID(tenantID),
	)
	if err != nil {
		log.Fatalf("Failed to create SCIM client: %v", err)
	}

	service := zscaler.NewZIAScimService(scimClient)
	ctx := context.Background()

	newUser := &scim_api.SCIMUser{
		Schemas: []string{
			"urn:ietf:params:scim:schemas:core:2.0:User",
			"urn:ietf:params:scim:schemas:extension:enterprise:2.0:User",
		},
		UserName:    "jdoe@acme.com",
		DisplayName: "John Doe",
		EnterpriseExtension: &scim_api.EnterpriseUser{
			Department: "Finance",
		},
	}

	createdUser, _, err := scim_api.CreateUser(ctx, service, newUser)
	if err != nil {
		log.Fatalf("Error creating SCIM user: %v", err)
	}
	log.Printf("User created: ID=%s, Department=%s", createdUser.ID, createdUser.EnterpriseExtension.Department)
}
```

--------------------------------

### Initialize ZDX Client

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/README.md

Configures and initializes the ZDX client using API credentials retrieved from environment variables.

```go
import (
 "log"
 "github.com/zscaler/zscaler-sdk-go/v3/zscaler/zdx"
 "github.com/zscaler/zscaler-sdk-go/v3/zscaler/zdx/services"
 "github.com/zscaler/zscaler-sdk-go/v3/zscaler/zdx/services/common"
 "github.com/zscaler/zscaler-sdk-go/v3/zscaler/zdx/services/reports/applications"
)

func main() {
	apiKey := os.Getenv("ZDX_API_KEY_ID")
	secretKey := os.Getenv("ZDX_API_SECRET")
	cloud := os.Getenv("ZDX_CLOUD") // Optional

 zdxCfg, err := zdx.NewConfiguration(
  zdx.WithZDXAPIKeyID(apiKey),
  zdx.WithZDXAPISecret(secretKey),
  zdx.WithZDXCloud(cloud),
  zdx.WithDebug(true),
 )
 if err != nil {
  log.Fatalf("Error creating ZDX configuration: %v", err)
 }

 zdxClient, err := zdx.NewClient(zdxCfg)
 if err != nil {
  log.Fatalf("Error creating ZDX client: %v", err)
 }

 service := services.New(zdxClient)

 filters := common.GetFromToFilters{
  From: 0, // Start time in epoch seconds (optional)
  To:   0, // End time in epoch seconds (optional)
 }

 apps, resp, err := applications.GetAllApps(service, filters)
 if err != nil {
  log.Fatalf("Error retrieving applications: %v", err)
 }

 log.Printf("Successfully retrieved %d applications.\n", len(apps))
 log.Printf("HTTP Response: %v\n", resp.Status)
 for _, app := range apps {
  log.Printf("Application Name: %s, ZDX Score: %.2f\n", app.Name, app.Score)
 }
}
```

--------------------------------

### Create a SCIM User in ZPA

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/examples/zpa_scim_api/users/create_user.md

Initializes the SCIM client using environment variables and creates a user with standard and enterprise attributes.

```go
package main

import (
	"context"
	"log"
	"os"

	"github.com/zscaler/zscaler-sdk-go/v3/zscaler"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zpa"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zpa/services/scim_api"
)

func main() {
	scimToken := os.Getenv("ZPA_SCIM_TOKEN")
	scimCloud := os.Getenv("ZPA_SCIM_CLOUD")
	IdpID 	  := os.Getenv("ZPA_IDP_ID")

	scimClient, err := zpa.NewScimConfig(
		zpa.WithScimToken(scimToken),
		zpa.WithScimCloud(scimCloud),
		zpa.WithIDPId(IdpID),
	)
	if err != nil {
		log.Fatalf("Failed to create SCIM client: %v", err)
	}

	service := zscaler.NewZPAScimService(scimClient)
	ctx := context.Background()

	newUser := &scim_api.ScimUser{
		Schemas: []string{
			"urn:ietf:params:scim:schemas:core:2.0:User",
			"urn:ietf:params:scim:schemas:extension:enterprise:2.0:User",
		},
		NickName:    "John Doe",
		UserType:    "ZPA User",
		UserName:    "johndoe@acme.com",
		Active:      true,
		DisplayName: "John Doe",
		Enterprise: scim_api.EnterpriseFields{
			Department: "A000",
		},
		Name: scim_api.Name{
			Formatted:  "John Doe <acme.com>",
			FamilyName: "Doe",
			GivenName:  "John",
		},
		Emails: []scim_api.Email{
			{Value: "johndoe@acme.com"},
		},
	}
	createdUser, _, err := scim_api.CreateUser(ctx, service, newUser)
	if err != nil {
		log.Fatalf("Error creating SCIM user: %v", err)
	}
	userID := createdUser.ID
	log.Printf("User created: ID=%s, UserName=%s", userID, createdUser.UserName)
}
```

--------------------------------

### Initialize OneAPI Client for FedRAMP

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/README.md

Configure the client programmatically by specifying the vanity domain and cloud type.

```go
import (
 "fmt"
 "github.com/zscaler/zscaler-sdk-go/v3/zscaler"
)

func main() {
  config, err := zscaler.NewConfiguration(
    zscaler.WithClientID(""),
    zscaler.WithClientSecret(""),
    zscaler.WithVanityDomain("acme"),
    zscaler.WithZscalerCloud("gov"), // or "govus"
  )
  if err != nil {
    fmt.Printf("Error: %v\n", err)
  }
  service, err := zscaler.NewOneAPIClient(config)
  _ = service
}
```

--------------------------------

### Create a SCIM Group in Go

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/examples/zia_scim_api/groups/create_group.md

Initializes the SCIM client using environment variables and creates a group with the specified display name and schema.

```go
package main

import (
	"context"
	"log"
	"os"

	"github.com/zscaler/zscaler-sdk-go/v3/zscaler"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zia"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zia/services/scim_api"
)

func main() {
	scimToken := os.Getenv("ZIA_SCIM_API_TOKEN")
	scimCloud := os.Getenv("ZIA_SCIM_CLOUD")
	tenantID := os.Getenv("ZIA_SCIM_TENANT_ID")

	scimClient, err := zia.NewScimConfig(
		zia.WithScimToken(scimToken),
		zia.WithScimCloud(scimCloud),
		zia.WithTenantID(tenantID),
	)
	if err != nil {
		log.Fatalf("Failed to create SCIM client: %v", err)
	}

	service := zscaler.NewZIAScimService(scimClient)
	ctx := context.Background()

		newGroup := &scim_api.SCIMGroup{
			Schemas:     []string{"urn:ietf:params:scim:schemas:core:2.0:Group"},
			DisplayName: groupName,
			Members: []scim_api.SCIMGroupMember{},
		}

		createdGroup, _, err := scim_api.CreateGroup(ctx, service, newGroup)
		if err != nil {
			log.Fatalf("Error creating SCIM group: %v", err)
		}
		groupID := createdGroup.ID
		log.Printf("Group created: ID=%s, DisplayName=%s", groupID, createdGroup.DisplayName)

}
```

--------------------------------

### Manage ZPA Application Servers

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/examples/zpa/zpa_application_server_controller/README.md

Initializes the ZPA client and performs a full lifecycle of an application server resource.

```go
package main

import (
	"log"

	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zpa"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zpa/services/appservercontroller"
)

func main() {
	zpa_client_id := os.Getenv("ZPA_CLIENT_ID")
	zpa_client_secret := os.Getenv("ZPA_CLIENT_SECRET")
	zpa_customer_id := os.Getenv("ZPA_CUSTOMER_ID")
	zpa_cloud := os.Getenv("ZPA_CLOUD")
	config, err := zpa.NewConfig(zpa_client_id, zpa_client_secret, zpa_customer_id, zpa_cloud, "userAgent")
	if err != nil {
		log.Printf("[ERROR] creating config failed: %v\n", err)
		return
	}
	zpaClient := zpa.NewClient(config)
	appServerControllerService := appservercontroller.New(zpaClient)
	app := appservercontroller.ApplicationServer{
		Name:                "Example application server ",
		Description:         "Example application server ",
		Enabled:             true,
		Address:             "192.168.1.1"
	}
	// Create new application server
	createdResource, _, err := appServerControllerService.Create(app)
	if err != nil {
		log.Printf("[ERROR] creating application server failed: %v\n", err)
		return
	}
	// Update application server
	createdResource.Description = "New description"
	_, err = appServerControllerService.Update(createdResource.ID, createdResource)
	if err != nil {
		log.Printf("[ERROR] updating application server  failed: %v\n", err)
		return
	}
	// Delete application server
	_, err = appServerControllerService.Delete(createdResource.ID)
	if err != nil {
		log.Printf("[ERROR] deleting application server failed: %v\n", err)
		return
	}
}
```

--------------------------------

### Create a ZIA Rule Label

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/README.md

Initializes a ZIA client and creates a new rule label with a unique name and description.

```go
import (
 "context"
 "fmt"
 "log"

 "github.com/zscaler/zscaler-sdk-go/v3/zscaler"
 "github.com/zscaler/zscaler-sdk-go/v3/zscaler/zia/services/rule_labels"
 "github.com/hashicorp/terraform-plugin-sdk/helper/acctest"
)

func main() {
 name := "tests-" + acctest.RandStringFromCharSet(10, acctest.CharSetAlpha)
 config, err := zscaler.NewConfiguration(
  zscaler.WithClientID(""),
  zscaler.WithClientSecret(""),
  zscaler.WithVanityDomain("acme"),
 )
 if err != nil {
  fmt.Printf("Error: %v\n", err)
 }

 service, err := zscaler.NewOneAPIClient(config)
 if err != nil {
  log.Fatalf("Error creating OneAPI client: %v", err)
 }

 ctx := context.Background()
 newLabel := &rule_labels.RuleLabels{
  Name:        name,
  Description: name,
 }
 createdLabel, _, err := rule_labels.Create(ctx, service, newLabel)
 if err != nil {
  log.Fatalf("Error creating rule label: %v", err)
 }
 fmt.Printf("Successfully created rule label: ID: %d, Name: %s\n", createdLabel.ID, createdLabel.Name)
}
```

--------------------------------

### Retrieve All SCIM Groups in Go

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/examples/zia_scim_api/groups/get_all_groups.md

Initializes the SCIM client using environment variables and retrieves all groups via the ZIA SCIM service.

```go
package main

import (
	"context"
	"log"
	"os"

	"github.com/zscaler/zscaler-sdk-go/v3/zscaler"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zia"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zia/services/scim_api"
)

func main() {
	scimToken := os.Getenv("ZIA_SCIM_API_TOKEN")
	scimCloud := os.Getenv("ZIA_SCIM_CLOUD")
	tenantID := os.Getenv("ZIA_SCIM_TENANT_ID")

	scimClient, err := zia.NewScimConfig(
		zia.WithScimToken(scimToken),
		zia.WithScimCloud(scimCloud),
		zia.WithTenantID(tenantID),
	)
	if err != nil {
		log.Fatalf("Failed to create SCIM client: %v", err)
	}

	service := zscaler.NewZIAScimService(scimClient)
	ctx := context.Background()

		allGroups, _, err := scim_api.GetAllGroups(ctx, service)
		if err != nil {
			log.Fatalf("Error listing SCIM groups: %v", err)
		}
		log.Printf("Total SCIM groups found: %d", len(allGroups))
}
```

--------------------------------

### Fetch a SCIM User

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/examples/zia_scim_api/users/get_user.md

Requires environment variables ZIA_SCIM_API_TOKEN, ZIA_SCIM_CLOUD, and ZIA_SCIM_TENANT_ID to be set for client authentication.

```go
package main

import (
	"context"
	"log"
	"os"

	"github.com/zscaler/zscaler-sdk-go/v3/zscaler"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zia"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zia/services/scim_api"
)

func main() {
	scimToken := os.Getenv("ZIA_SCIM_API_TOKEN")
	scimCloud := os.Getenv("ZIA_SCIM_CLOUD")
	tenantID := os.Getenv("ZIA_SCIM_TENANT_ID")

	scimClient, err := zia.NewScimConfig(
		zia.WithScimToken(scimToken),
		zia.WithScimCloud(scimCloud),
		zia.WithTenantID(tenantID),
	)
	if err != nil {
		log.Fatalf("Failed to create SCIM client: %v", err)
	}

	service := zscaler.NewZIAScimService(scimClient)
	ctx := context.Background()

	fetchedUser, _, err := scim_api.GetUser(ctx, service, "83b86518-77f3-4059-9aa5-be999c5d1fc9")
	if err != nil {
		log.Fatalf("Error fetching SCIM user: %v", err)
	}
	log.Printf("User fetched: ID=%s, Department=%s", fetchedUser.ID, fetchedUser.EnterpriseExtension.Department)
}
```

--------------------------------

### Create a SCIM Group in ZPA

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/examples/zpa_scim_api/groups/create_group.md

Initializes the SCIM client using environment variables and creates a new group with the specified display name and schema.

```go
package main

import (
	"context"
	"log"
	"os"

	"github.com/zscaler/zscaler-sdk-go/v3/zscaler"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zpa"
	"github.com/zscaler/zscaler-sdk-go/v3/zscaler/zpa/services/scim_api"
)

func main() {
	scimToken := os.Getenv("ZPA_SCIM_TOKEN")
	scimCloud := os.Getenv("ZPA_SCIM_CLOUD")
	IdpID 	  := os.Getenv("ZPA_IDP_ID")

	scimClient, err := zpa.NewScimConfig(
		zpa.WithScimToken(scimToken),
		zpa.WithScimCloud(scimCloud),
		zpa.WithIDPId(IdpID),
	)
	if err != nil {
		log.Fatalf("Failed to create SCIM client: %v", err)
	}

	service := zscaler.NewZPAScimService(scimClient)
	ctx := context.Background()

		newGroup := &scim_api.ScimGroup{
			Schemas:     []string{"urn:ietf:params:scim:schemas:core:2.0:Group"},
			DisplayName: groupName,
			Members: []scim_api.SCIMGroupMember{},
		}

		createdGroup, _, err := scim_api.CreateGroup(ctx, service, newGroup)
		if err != nil {
			log.Fatalf("Error creating SCIM group: %v", err)
		}
		groupID := createdGroup.ID
		log.Printf("Group created: ID=%s, DisplayName=%s", groupID, createdGroup.DisplayName)
}
```

--------------------------------

### Retrieve ZIA Sub-locations and Details

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/examples/zia/zia_sub_location/README.md

Demonstrates how to initialize the ZIA client and use the locationmanagement service to fetch sub-location data via various identifiers.

```go
package main

import (
    "log"
    "os"

    "github.com/zscaler/zscaler-sdk-go/v3/zia"
    "github.com/zscaler/zscaler-sdk-go/v3/zia/services/locationmanagement"
)

func main() {
    username := os.Getenv("ZIA_USERNAME")
    password := os.Getenv("ZIA_PASSWORD")
    apiKey := os.Getenv("ZIA_API_KEY")
    ziaCloud := os.Getenv("ZIA_CLOUD")

    cli, err := zia.NewClient(username, password, apiKey, ziaCloud, "userAgent")
    if err != nil {
        log.Printf("[ERROR] creating client failed: %v\n", err)
        return
    }

    locationmanagementService := locationmanagement.New(cli)

    locations, err := locationmanagementService.GetSublocations(12008136)
    if err == nil {
        log.Printf("GetSublocations -> locations: %v\n", locations)
    } else {
        log.Printf("GetSublocations -> error: %v", err)
    }

    location, err := locationmanagementService.GetSubLocation(12008136, 12008137)
    if err == nil {
        log.Printf("GetSubLocation -> location: %v\n", location)
    } else {
        log.Printf("GetSubLocation -> error: %v", err)
    }

    location, err = locationmanagementService.GetSubLocationByName("Guest Wi-Fi - Branch01")
    if err == nil {
        log.Printf("GetSubLocationByName -> location: %v\n", location)
    } else {
        log.Printf("GetSubLocationByName -> error: %v", err)
    }

    location, err = locationmanagementService.GetSubLocationByNames("BR - Sao Paulo - Branch01", "Guest Wi-Fi - Branch01")
    if err == nil {
        log.Printf("GetSubLocationByNames -> location: %v\n", location)
    } else {
        log.Printf("GetSubLocationByNames -> error: %v", err)
    }

    location, err = locationmanagementService.GetSubLocationBySubID(12008137)
    if err == nil {
        log.Printf("GetSubLocationBySubID -> location: %v\n", location)
    } else {
        log.Printf("GetSubLocationBySubID -> error: %v", err)
    }

    location, err = locationmanagementService.GetLocationOrSublocationByID(12008137)
    if err == nil {
        log.Printf("GetLocationOrSublocationByID -> location: %v\n", location)
    } else {
        log.Printf("GetLocationOrSublocationByID -> error: %v", err)
    }

    location, err = locationmanagementService.GetLocationOrSublocationByName("Guest Wi-Fi - Branch01")
    if err == nil {
        log.Printf("GetLocationOrSublocationByName -> location: %v\n", location)
    } else {
        log.Printf("GetLocationOrSublocationByName -> error: %v", err)
    }
}
```

--------------------------------

### Initialize ZPA Client

Source: https://github.com/zscaler/zscaler-sdk-go/blob/master/README.md

Configures a ZPA client using environment variables and retrieves segment groups. The ZPA_CLOUD environment variable is mandatory for identifying the correct API gateway.

```go
import (
 "context"
 "fmt"
 "log"

 "github.com/zscaler/zscaler-sdk-go/v3/zscaler"
 "github.com/zscaler/zscaler-sdk-go/v3/zscaler/zpa"
 "github.com/zscaler/zscaler-sdk-go/v3/zscaler/zpa/services/segmentgroup"
)

func main() {
	clientID := os.Getenv("ZPA_CLIENT_ID")
	clientSecret := os.Getenv("ZPA_CLIENT_SECRET")
	customerID   := os.Getenv("ZPA_CUSTOMER_ID")
	cloud := os.Getenv("ZPA_CLOUD")

	zpaCfg, err := zpa.NewConfiguration(
		zpa.WithZPAClientID(clientID),
		zpa.WithZPAClientSecret(clientSecret),
		zpa.WithZPACustomerID(customerID),
		zpa.WithZPACloud(cloud),
	)
	if err != nil {
		log.Fatalf("Error creating ZPA configuration: %v", err)
	}

	// Initialize ZPA client
	service, err := zscaler.NewLegacyZpaClient(zpaCfg)
	if err != nil {
		log.Fatalf("Error creating ZPA client: %v", err)
	}

 ctx := context.Background()

 groups, resp, err := segmentgroup.GetAll(ctx, service)
 if err != nil {
  log.Fatalf("Error list all segment group: %v", err)
 }
 fmt.Printf("Groups: %+v\n Response: %+v\n\n", groups, resp)
 for index, group := range groups {
  fmt.Printf("Group %d: %+v\n", index, group)
 }
}
```
Tokens:
Raw