securitycloud

package
v1.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Sep 15, 2026 License: MIT Imports: 9 Imported by: 0

Documentation

Overview

Package securitycloud provides typed access to Jamf Platform securitycloud API endpoints.

Index

Constants

This section is empty.

Variables

View Source
var Privileges = map[string]jamfplatform.MethodPrivileges{
	"CancelUemConnectorSyncV1":           {Method: "CancelUemConnectorSyncV1", HTTPMethod: "DELETE", Path: "//uem-connect/v1/connectors/{configId}/sync/runs/current", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"uem-connect:update"}, Legacy: nil, Source: "spec"},
	"ClearDnsCustomHostnameMappingsV1":   {Method: "ClearDnsCustomHostnameMappingsV1", HTTPMethod: "DELETE", Path: "/v1/dns/custom-hostname-mappings", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"custom-hostname-mappings:delete"}, Legacy: nil, Source: "spec"},
	"ClearDnsSearchDomainV1":             {Method: "ClearDnsSearchDomainV1", HTTPMethod: "DELETE", Path: "/v1/dns/search-domains", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"search-domains:delete"}, Legacy: nil, Source: "spec"},
	"CreateActivationProfileV1":          {Method: "CreateActivationProfileV1", HTTPMethod: "POST", Path: "/v1/activation-profiles", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"activation-profiles:create"}, Legacy: nil, Source: "spec"},
	"CreateDeviceGroupV1":                {Method: "CreateDeviceGroupV1", HTTPMethod: "POST", Path: "/v1/groups", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"device-groups:create"}, Legacy: nil, Source: "spec"},
	"CreateDnsZoneV1":                    {Method: "CreateDnsZoneV1", HTTPMethod: "POST", Path: "/v1/dns/zones", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:create"}, Legacy: nil, Source: "spec"},
	"CreateUemConnectorV1":               {Method: "CreateUemConnectorV1", HTTPMethod: "POST", Path: "//uem-connect/v1/connectors", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"uem-connect:create"}, Legacy: nil, Source: "spec"},
	"CreateZtnaAppV1":                    {Method: "CreateZtnaAppV1", HTTPMethod: "POST", Path: "/v1/ztna/apps", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:create"}, Legacy: nil, Source: "spec"},
	"CreateZtnaGatewayV1":                {Method: "CreateZtnaGatewayV1", HTTPMethod: "POST", Path: "/v1/ztna/gateways", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:create"}, Legacy: nil, Source: "spec"},
	"CreateZtnaGroupedGatewayV1":         {Method: "CreateZtnaGroupedGatewayV1", HTTPMethod: "POST", Path: "/v1/ztna/grouped-gateways", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:create"}, Legacy: nil, Source: "spec"},
	"DeleteActivationProfilesV1":         {Method: "DeleteActivationProfilesV1", HTTPMethod: "POST", Path: "/v1/activation-profiles/delete-multiple", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"activation-profiles:delete"}, Legacy: nil, Source: "spec"},
	"DeleteDeviceGroupV1":                {Method: "DeleteDeviceGroupV1", HTTPMethod: "DELETE", Path: "/v1/groups/{groupId}", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"device-groups:delete"}, Legacy: nil, Source: "spec"},
	"DeleteDnsZoneV1":                    {Method: "DeleteDnsZoneV1", HTTPMethod: "DELETE", Path: "/v1/dns/zones/{id}", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:delete"}, Legacy: nil, Source: "spec"},
	"DeleteUemConnectorV1":               {Method: "DeleteUemConnectorV1", HTTPMethod: "DELETE", Path: "//uem-connect/v1/connectors/{configId}", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"uem-connect:delete"}, Legacy: nil, Source: "spec"},
	"DeleteZtnaAppV1":                    {Method: "DeleteZtnaAppV1", HTTPMethod: "DELETE", Path: "/v1/ztna/apps/{appId}", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:delete"}, Legacy: nil, Source: "spec"},
	"DeleteZtnaGatewayV1":                {Method: "DeleteZtnaGatewayV1", HTTPMethod: "DELETE", Path: "/v1/ztna/gateways/{gatewayId}", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:delete"}, Legacy: nil, Source: "spec"},
	"DeleteZtnaGroupedGatewayV1":         {Method: "DeleteZtnaGroupedGatewayV1", HTTPMethod: "DELETE", Path: "/v1/ztna/grouped-gateways/{groupedGatewayId}", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:delete"}, Legacy: nil, Source: "spec"},
	"DeployActivationProfileToUemV1":     {Method: "DeployActivationProfileToUemV1", HTTPMethod: "POST", Path: "//uem-connect/v1/activation-profiles/{code}/deploy-to-uem", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"uem-connect:update"}, Legacy: nil, Source: "spec"},
	"DisableUemConnectorV1":              {Method: "DisableUemConnectorV1", HTTPMethod: "DELETE", Path: "//uem-connect/v1/connectors/{configId}/enablement", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"uem-connect:delete"}, Legacy: nil, Source: "spec"},
	"EnableUemConnectorV1":               {Method: "EnableUemConnectorV1", HTTPMethod: "PUT", Path: "//uem-connect/v1/connectors/{configId}/enablement", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"uem-connect:update"}, Legacy: nil, Source: "spec"},
	"GetActivationProfileV1":             {Method: "GetActivationProfileV1", HTTPMethod: "GET", Path: "/v1/activation-profiles/{activationProfileId}", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"activation-profiles:read"}, Legacy: nil, Source: "spec"},
	"GetDeviceGroupV1":                   {Method: "GetDeviceGroupV1", HTTPMethod: "GET", Path: "/v1/groups/{groupId}", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"device-groups:read"}, Legacy: nil, Source: "spec"},
	"GetDnsCustomHostnameMappingsV1":     {Method: "GetDnsCustomHostnameMappingsV1", HTTPMethod: "GET", Path: "/v1/dns/custom-hostname-mappings", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"custom-hostname-mappings:read"}, Legacy: nil, Source: "spec"},
	"GetDnsSearchDomainV1":               {Method: "GetDnsSearchDomainV1", HTTPMethod: "GET", Path: "/v1/dns/search-domains", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"search-domains:read"}, Legacy: nil, Source: "spec"},
	"GetDnsZoneV1":                       {Method: "GetDnsZoneV1", HTTPMethod: "GET", Path: "/v1/dns/zones/{id}", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:read"}, Legacy: nil, Source: "spec"},
	"GetUemConnectorSyncSettingsV1":      {Method: "GetUemConnectorSyncSettingsV1", HTTPMethod: "GET", Path: "//uem-connect/v1/connectors/{configId}/sync-settings", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"uem-connect:read"}, Legacy: nil, Source: "spec"},
	"GetUemConnectorV1":                  {Method: "GetUemConnectorV1", HTTPMethod: "GET", Path: "//uem-connect/v1/connectors/{configId}", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"uem-connect:read"}, Legacy: nil, Source: "spec"},
	"GetZtnaAppV1":                       {Method: "GetZtnaAppV1", HTTPMethod: "GET", Path: "/v1/ztna/apps/{appId}", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:read"}, Legacy: nil, Source: "spec"},
	"GetZtnaGatewayV1":                   {Method: "GetZtnaGatewayV1", HTTPMethod: "GET", Path: "/v1/ztna/gateways/{gatewayId}", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:read"}, Legacy: nil, Source: "spec"},
	"GetZtnaGroupedGatewayV1":            {Method: "GetZtnaGroupedGatewayV1", HTTPMethod: "GET", Path: "/v1/ztna/grouped-gateways/{groupedGatewayId}", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:read"}, Legacy: nil, Source: "spec"},
	"ListActivationProfilesV1":           {Method: "ListActivationProfilesV1", HTTPMethod: "GET", Path: "/v1/activation-profiles", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"activation-profiles:read"}, Legacy: nil, Source: "spec"},
	"ListContentCategoriesV1":            {Method: "ListContentCategoriesV1", HTTPMethod: "GET", Path: "/v1/categories", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"content-categories:read"}, Legacy: nil, Source: "spec"},
	"ListDeviceGroupsV2":                 {Method: "ListDeviceGroupsV2", HTTPMethod: "GET", Path: "/v2/groups", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"device-groups:read"}, Legacy: nil, Source: "spec"},
	"ListDnsZonesV1":                     {Method: "ListDnsZonesV1", HTTPMethod: "GET", Path: "/v1/dns/zones", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:read"}, Legacy: nil, Source: "spec"},
	"ListUemConnectorSyncRunsV1":         {Method: "ListUemConnectorSyncRunsV1", HTTPMethod: "GET", Path: "//uem-connect/v1/connectors/{configId}/sync/runs", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"uem-connect:read"}, Legacy: nil, Source: "spec"},
	"ListUemConnectorsV1":                {Method: "ListUemConnectorsV1", HTTPMethod: "GET", Path: "//uem-connect/v1/connectors", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"uem-connect:read"}, Legacy: nil, Source: "spec"},
	"ListZtnaAppsV1":                     {Method: "ListZtnaAppsV1", HTTPMethod: "GET", Path: "/v1/ztna/apps", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:read"}, Legacy: nil, Source: "spec"},
	"ListZtnaGatewaysV1":                 {Method: "ListZtnaGatewaysV1", HTTPMethod: "GET", Path: "/v1/ztna/gateways", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:read"}, Legacy: nil, Source: "spec"},
	"ListZtnaGroupedGatewaysV1":          {Method: "ListZtnaGroupedGatewaysV1", HTTPMethod: "GET", Path: "/v1/ztna/grouped-gateways", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:read"}, Legacy: nil, Source: "spec"},
	"ListZtnaPredefinedAppsV1":           {Method: "ListZtnaPredefinedAppsV1", HTTPMethod: "GET", Path: "/v1/ztna/predefined-apps", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:read"}, Legacy: nil, Source: "spec"},
	"ListZtnaSharedGatewaysV1":           {Method: "ListZtnaSharedGatewaysV1", HTTPMethod: "GET", Path: "/v1/ztna/shared-gateways", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:read"}, Legacy: nil, Source: "spec"},
	"PauseActivationProfileV1":           {Method: "PauseActivationProfileV1", HTTPMethod: "POST", Path: "/v1/activation-profiles/{activationProfileId}/pause", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"activation-profiles:update"}, Legacy: nil, Source: "spec"},
	"ReplaceDnsCustomHostnameMappingsV1": {Method: "ReplaceDnsCustomHostnameMappingsV1", HTTPMethod: "PUT", Path: "/v1/dns/custom-hostname-mappings", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"custom-hostname-mappings:update"}, Legacy: nil, Source: "spec"},
	"ResumeActivationProfileV1":          {Method: "ResumeActivationProfileV1", HTTPMethod: "POST", Path: "/v1/activation-profiles/{activationProfileId}/resume", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"activation-profiles:update"}, Legacy: nil, Source: "spec"},
	"SetDnsSearchDomainV1":               {Method: "SetDnsSearchDomainV1", HTTPMethod: "PUT", Path: "/v1/dns/search-domains", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"search-domains:update"}, Legacy: nil, Source: "spec"},
	"TriggerUemConnectorSyncV1":          {Method: "TriggerUemConnectorSyncV1", HTTPMethod: "POST", Path: "//uem-connect/v1/connectors/{configId}/sync/runs", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"uem-connect:update"}, Legacy: nil, Source: "spec"},
	"UpdateDeviceGroupV2":                {Method: "UpdateDeviceGroupV2", HTTPMethod: "PUT", Path: "/v2/groups/{groupId}", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"device-groups:update"}, Legacy: nil, Source: "spec"},
	"UpdateDnsZoneV1":                    {Method: "UpdateDnsZoneV1", HTTPMethod: "PATCH", Path: "/v1/dns/zones/{id}", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:update"}, Legacy: nil, Source: "spec"},
	"UpdateUemConnectorSyncSettingsV1":   {Method: "UpdateUemConnectorSyncSettingsV1", HTTPMethod: "PUT", Path: "//uem-connect/v1/connectors/{configId}/sync-settings", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"uem-connect:update"}, Legacy: nil, Source: "spec"},
	"UpdateZtnaAppV1":                    {Method: "UpdateZtnaAppV1", HTTPMethod: "PATCH", Path: "/v1/ztna/apps/{appId}", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:update"}, Legacy: nil, Source: "spec"},
	"UpdateZtnaGatewayV1":                {Method: "UpdateZtnaGatewayV1", HTTPMethod: "PATCH", Path: "/v1/ztna/gateways/{gatewayId}", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:update"}, Legacy: nil, Source: "spec"},
	"UpdateZtnaGroupedGatewayV1":         {Method: "UpdateZtnaGroupedGatewayV1", HTTPMethod: "PATCH", Path: "/v1/ztna/grouped-gateways/{groupedGatewayId}", Scopes: []jamfplatform.ScopeKind{jamfplatform.ScopeTenant, jamfplatform.ScopeEnvironment}, ScopesSource: "spec", Scoped: []string{"ztna:update"}, Legacy: nil, Source: "spec"},
}

Privileges maps each securitycloud SDK method name to the Jamf API privileges it requires, sourced from the x-required-privileges vendor extensions in the Jamf OpenAPI specs. Identifiers are GA capability permissions in {capability}:{action} form and a multi-entry Scoped slice means all of them are required.

Source names where each entry's Scoped set came from: "spec" for the operation's own x-required-privileges, "gateway-policy" for one the published spec omits and this SDK supplies from the gateway's authorization policy, and "" when Scoped is empty. An empty Scoped slice means nothing declares a privilege for the endpoint, which is NOT the same as none being required — see jamfplatform.MethodPrivileges. Do not render it as "no permission needed".

Scopes lists the scope kinds each endpoint accepts. It is an alternatives set: a client carries one scope, so a consumer needs a credential matching one of the listed kinds. ScopesSource names where the set came from — "spec" for the spec root's own x-scope-types, "config-override" for one this SDK supplies because the published spec understates what the gateway serves or declares no extension at all. A spec-sourced set is what the spec declares, which for the Platform APIs is currently stricter than the gateway — see jamfplatform.MethodPrivileges.

Synthetic Resolve<X>ByName / Apply<X> methods are not present; document the privileges of the operations they call instead.

Functions

func PrivilegesFor

func PrivilegesFor(method string) (jamfplatform.MethodPrivileges, bool)

PrivilegesFor returns the privilege metadata for the named SDK method and true when the method is present in the registry, or the zero value and false otherwise.

Types

type ActivationProfile

type ActivationProfile struct {
	// Unique identifier code for the activation profile.
	Code string `json:"code"`
}

ActivationProfile A single activation profile resource. The whole read model: a code, and nothing else. There is no name, no capability set, no platform list and no state, so nothing a create sends can be read back and `PauseActivationProfileV1` / `ResumeActivationProfileV1` have no observable effect on any GET. **Deletion is a soft delete that the read surface does not reflect** (wire-verified 2026-09-01). After `DeleteActivationProfilesV1` succeeds, `GetActivationProfileV1` still answers 200 for the deleted code and `ListActivationProfilesV1` still returns it, indistinguishable from a live profile. The only surface that reveals the state is a write: pause or resume on a deleted code answers `409 STATE_CONFLICT` (`Activation profile with code: is already deleted.`). So a caller cannot confirm a delete, and cannot filter deleted profiles out of a list.

type ActivationProfileDeployRequest

type ActivationProfileDeployRequest struct {
	// The device platform type for the configuration profile.
	// Allowed values: see the ActivationProfileDeployRequestPlatform constants.
	Platform string `json:"platform"`
	// The UEM platform to deploy profiles to.
	// Allowed values: see the ActivationProfileDeployRequestUem constants.
	Uem string `json:"uem"`
	// Optional UEM group IDs to scope the deployment to.
	// Group names are not accepted. These are the UEM's own group IDs — for Jamf Pro, obtain them from
	// the Jamf Pro API (`GET /v1/computer-groups`, `GET /v1/mobile-device-groups`). An ID is either bare
	// numeric (`"123"`) or device-type-prefixed (`"computer_123"`, `"mobile_456"`); a prefix, when
	// present, must match the device type the `platform` deploys to. IDs are scoped to a single UEM
	// instance.
	// Scoping is additive: the IDs are merged into the configuration profile's existing scope, so a later
	// deploy can widen the scope but cannot narrow or clear it. Omitting the field or sending an empty
	// array leaves any existing scope untouched — on the first deploy of a profile it means no group
	// scope is set, not that the profile is scoped to every group.
	UemGroups *[]string `json:"uemGroups,omitempty"`
}

ActivationProfileDeployRequest Request to deploy activation profile configuration profiles to UEM.

type ActivationProfileDeployRequestPlatform

type ActivationProfileDeployRequestPlatform = string

ActivationProfileDeployRequestPlatform is the set of values accepted by ActivationProfileDeployRequest.Platform.

const (
	ActivationProfileDeployRequestPlatformSupervisedMac   ActivationProfileDeployRequestPlatform = "SUPERVISED_MAC"
	ActivationProfileDeployRequestPlatformSupervisedIos   ActivationProfileDeployRequestPlatform = "SUPERVISED_IOS"
	ActivationProfileDeployRequestPlatformUnsupervisedIos ActivationProfileDeployRequestPlatform = "UNSUPERVISED_IOS"
	ActivationProfileDeployRequestPlatformByodIos         ActivationProfileDeployRequestPlatform = "BYOD_IOS"
)

ActivationProfileDeployRequestPlatform values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func ActivationProfileDeployRequestPlatformValues

func ActivationProfileDeployRequestPlatformValues() []ActivationProfileDeployRequestPlatform

ActivationProfileDeployRequestPlatformValues returns every value the Jamf API accepts for ActivationProfileDeployRequestPlatform, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type ActivationProfileDeployRequestUem

type ActivationProfileDeployRequestUem = string

ActivationProfileDeployRequestUem is the set of values accepted by ActivationProfileDeployRequest.Uem.

const (
	ActivationProfileDeployRequestUemJamf ActivationProfileDeployRequestUem = "JAMF"
)

ActivationProfileDeployRequestUem values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func ActivationProfileDeployRequestUemValues

func ActivationProfileDeployRequestUemValues() []ActivationProfileDeployRequestUem

ActivationProfileDeployRequestUemValues returns every value the Jamf API accepts for ActivationProfileDeployRequestUem, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type ActivationProfileResponse

type ActivationProfileResponse struct {
	// URL of the created activation profile.
	Href string `json:"href"`
	// Unique identifier code for the newly created activation profile.
	ID string `json:"id"`
}

ActivationProfileResponse Response body returned after successfully creating an activation profile. Declared as the 201 body of `POST /v1/activation-profiles` and never sent. The server answers `{"code": "..."}` — an ActivationProfile — with no `id`, no `href` and no `Location` header, wire-verified 2026-09-01 both with and without `Accept-Encoding: gzip`, so this is not the href-injection plugin nulling a compressed body the way it does on the DNS and ZTNA creates. `CreateActivationProfileV1` therefore returns `*ActivationProfile` via a `responseType` override; decoding into this type would have silently produced a zero-valued struct. Kept only because the spec declares it.

type ActivationProfilesResponse

type ActivationProfilesResponse struct {
	// List of activation profiles. Returns empty array if no profiles exist.
	ActivationProfiles []ActivationProfile `json:"activationProfiles"`
}

ActivationProfilesResponse List of activation profiles for the customer.

type ApiError

type ApiError struct {
	// The list of individual errors that occurred while processing the request.
	Errors []ApiErrorItem `json:"errors"`
	// HTTP status code of the response.
	HttpStatus int `json:"httpStatus"`
	// Trace identifier correlating the response with server-side logs. May be absent on infrastructure
	// errors such as bare 500/503.
	TraceID *string `json:"traceId,omitempty"`
}

ApiError Standard Jamf error response body returned for non-2xx/3xx responses.

type ApiErrorEntry

type ApiErrorEntry struct {
	// Machine-readable error code.
	Code string `json:"code"`
	// Human-readable explanation.
	Description string `json:"description"`
	// The request field the error relates to, when applicable.
	Field *string `json:"field,omitempty"`
}

ApiErrorEntry A single problem with the request.

type ApiErrorErrorsItem

type ApiErrorErrorsItem struct {
	// Machine-readable error code.
	Code string `json:"code"`
	// Human-readable description for debugging. Do not display to end users.
	Description string `json:"description"`
	// Name of the field that caused the error, if applicable.
	Field string `json:"field"`
	// ID of the object with the error, if applicable.
	ID string `json:"id"`
}

ApiErrorErrorsItem represents a api error errors item.

type ApiErrorItem

type ApiErrorItem struct {
	// Error-specific code that can be used to identify a localization string, etc.
	// Allowed values: see the ApiErrorItemCode constants.
	Code string `json:"code"`
	// A general description of the error for troubleshooting and debugging. Generally this text should not
	// be displayed to a user; instead refer to the code and its localized text. May be null.
	Description *string `json:"description,omitempty"`
	// Name of the field that caused the error. Optional.
	Field *string `json:"field,omitempty"`
	// Identifier of the object with the error. Optional.
	ID *string `json:"id,omitempty"`
}

ApiErrorItem A single error detail within an ApiError response.

type ApiErrorItemCode

type ApiErrorItemCode = string

ApiErrorItemCode is the set of values accepted by ApiErrorItem.Code.

const (
	ApiErrorItemCodeInvalidField           ApiErrorItemCode = "INVALID_FIELD"
	ApiErrorItemCodeListSizeExceeded       ApiErrorItemCode = "LIST_SIZE_EXCEEDED"
	ApiErrorItemCodeDomainConflict         ApiErrorItemCode = "DOMAIN_CONFLICT"
	ApiErrorItemCodeGatewayNotFound        ApiErrorItemCode = "GATEWAY_NOT_FOUND"
	ApiErrorItemCodeNameserverIpOutOfRange ApiErrorItemCode = "NAMESERVER_IP_OUT_OF_RANGE"
	ApiErrorItemCodeNameserverIpRestricted ApiErrorItemCode = "NAMESERVER_IP_RESTRICTED"
	ApiErrorItemCodeZoneNotFound           ApiErrorItemCode = "ZONE_NOT_FOUND"
	ApiErrorItemCodeSearchDomainNotSet     ApiErrorItemCode = "SEARCH_DOMAIN_NOT_SET"
	ApiErrorItemCodeNotEntitled            ApiErrorItemCode = "NOT_ENTITLED"
)

ApiErrorItemCode values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func ApiErrorItemCodeValues

func ApiErrorItemCodeValues() []ApiErrorItemCode

ApiErrorItemCodeValues returns every value the Jamf API accepts for ApiErrorItemCode, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type App

type App struct {
	// User/group assignment rules for an App.
	Assignments *Assignments `json:"assignments,omitempty"`
	// IPv4 CIDR subnets (e.g. `192.168.1.0/24`). Duplicating a subnet across Apps returns 409.
	BareIps []string `json:"bareIps"`
	// App category name. Must exactly match a `displayName` returned by `GET /v1/categories` (e.g.
	// `"Business & Industry"`) — that endpoint is the authoritative source. Unknown values return `409
	// MISSING_CATEGORY_NAME` — the category list is server-owned and may change, so an unrecognized name
	// is a state conflict, not a malformed request.
	CategoryName CategoryName `json:"categoryName"`
	// Per-group routing overrides that take precedence over the App's default routing. Each override's
	// `groupIds` must be a subset of `assignments.inclusions.groups` (or `allUsers: true`); references to
	// unassigned groups return `400`.
	GroupOverrides *GroupOverrides `json:"groupOverrides,omitempty"`
	// Hostnames/domains for traffic matching. Each entry must be a valid domain name, `"*"` (full-tunnel
	// wildcard), or a wildcard prefix (`"*.example.com"`). Overlapping entries are rejected — e.g.
	// `["*.example.com", "sub.example.com"]` returns `400` because `sub.example.com` is covered by
	// `*.example.com`. Duplicating a hostname across Apps returns `409`.
	Hostnames []string `json:"hostnames"`
	// App ID. Format: UUID (e.g. `3fa85f64-5717-4562-b3fc-2c963f66afa6`).
	ID string `json:"id"`
	// Null when `predefinedAppId` is set — the name is owned by the predefined app template. Present and
	// non-null when `predefinedAppId` is absent (custom app).
	Name *string `json:"name,omitempty"`
	// ID of the predefined SaaS app template (from `GET /predefined-apps`). Once set, cannot be changed or
	// removed. When set, `name` is null (owned by the template); additional `hostnames` can still be
	// appended.
	PredefinedAppID *string `json:"predefinedAppId,omitempty"`
	// Traffic routing configuration for an App.
	Routing *Routing `json:"routing,omitempty"`
	// Security controls applied to App traffic.
	Security *AppSecurity `json:"security,omitempty"`
}

App An App (Access Policy) defining ZTNA routing for a set of hostnames/IPs.

type AppCreateRequest

type AppCreateRequest struct {
	// User/group assignment rules for an App.
	Assignments Assignments `json:"assignments"`
	// IPv4 CIDR subnets (e.g. `192.168.1.0/24`). Duplicating a subnet across Apps returns 409.
	BareIps *[]string `json:"bareIps,omitempty"`
	// App category name. Must exactly match a `displayName` returned by `GET /v1/categories` (e.g.
	// `"Business & Industry"`) — that endpoint is the authoritative source. Unknown values return `409
	// MISSING_CATEGORY_NAME` — the category list is server-owned and may change, so an unrecognized name
	// is a state conflict, not a malformed request.
	CategoryName CategoryName `json:"categoryName"`
	// Per-group routing overrides that take precedence over the App's default routing. Each override's
	// `groupIds` must be a subset of `assignments.inclusions.groups` (or `allUsers: true`); references to
	// unassigned groups return `400`.
	GroupOverrides *GroupOverrides `json:"groupOverrides,omitempty"`
	// Unique set of hostnames/domains. Each entry must be a valid domain name, `"*"`, or `"*.domain"`.
	// Overlapping entries (e.g. `["*.example.com", "sub.example.com"]`) return `400`. Specifying the same
	// hostname across multiple Apps returns `409`. When `predefinedAppId` is set, additional hostnames
	// extend the template set.
	Hostnames *[]string `json:"hostnames,omitempty"`
	// Required (non-null) when `predefinedAppId` is absent — `400` if missing or null. Must be null or
	// omitted when `predefinedAppId` is set.
	Name *string `json:"name,omitempty"`
	// Optional. ID from `GET /predefined-apps`. Once set, cannot be changed or removed. When set, `name`
	// must be null or omitted; additional `hostnames` can be appended. Presence indicates a Predefined
	// (SaaS) App; absence indicates a Custom (Enterprise) App.
	PredefinedAppID *string `json:"predefinedAppId,omitempty"`
	// Traffic routing configuration for an App.
	Routing Routing `json:"routing"`
	// Security controls applied to App traffic.
	Security *AppSecurity `json:"security,omitempty"`
}

AppCreateRequest Request body for creating an App. Two corrections to the `name` and `predefinedAppId` descriptions above, both wire-verified 2026-08-30. First, `name` supplied alongside `predefinedAppId` does not return `400`. The request succeeds with `201` and the name is silently discarded — the created app reads back `"name": null`. PATCHing `name` on a predefined app is likewise `204` and likewise ignored. A caller that wants the supplied name to mean something must refuse the combination itself, because the server will not. Second, a tenant may hold only one app per predefined app template. Reusing a `predefinedAppId` that another app already references is refused with `409 CONFLICT` and the bare description "Resource already exists." — naming neither the field nor the template, and using the generic fallback code rather than a specific one.

type AppListResponse

type AppListResponse struct {
	Results []App `json:"results"`
	// Total number of items across all pages.
	TotalCount int `json:"totalCount"`
}

AppListResponse List of Apps with a total count.

type AppPatchRequest

type AppPatchRequest struct {
	// User/group assignment rules for an App.
	Assignments *Assignments `json:"assignments,omitempty"`
	// Replaces the full bareIps list. IPv4 CIDR subnets (e.g. `192.168.1.0/24`).
	BareIps *[]string `json:"bareIps,omitempty"`
	// App category name. Must exactly match a `displayName` returned by `GET /v1/categories` (e.g.
	// `"Business & Industry"`) — that endpoint is the authoritative source. Unknown values return `409
	// MISSING_CATEGORY_NAME` — the category list is server-owned and may change, so an unrecognized name
	// is a state conflict, not a malformed request.
	CategoryName *CategoryName `json:"categoryName,omitempty"`
	// Per-group routing overrides that take precedence over the App's default routing. Each override's
	// `groupIds` must be a subset of `assignments.inclusions.groups` (or `allUsers: true`); references to
	// unassigned groups return `400`.
	GroupOverrides *GroupOverrides `json:"groupOverrides,omitempty"`
	// Replaces the full hostname list. Each entry must be a valid domain name, `"*"`, or `"*.domain"`.
	// Overlapping entries (e.g. `["*.example.com", "sub.example.com"]`) return `400`. Specifying the same
	// hostname as another App returns `409`.
	Hostnames *[]string `json:"hostnames,omitempty"`
	// New name. Must be non-empty — a blank string returns `400`. Ignored when `predefinedAppId` is set
	// (name is owned by the template). Omit to leave unchanged.
	Name *string `json:"name,omitempty"`
	// Traffic routing configuration for an App.
	Routing *Routing `json:"routing,omitempty"`
	// Security controls applied to App traffic.
	Security *AppSecurity `json:"security,omitempty"`
}

AppPatchRequest Merge-patch body (`application/merge-patch+json`) for partial App update. All fields optional — include only what you want to change.

type AppSecurity

type AppSecurity struct {
	// Device management enrollment-based access control.
	DeviceManagementBasedAccess *DeviceManagementBasedAccess `json:"deviceManagementBasedAccess,omitempty"`
	// DNS-over-HTTPS integration settings for the App.
	DohIntegration *DohIntegration `json:"dohIntegration,omitempty"`
	// Risk-based access controls for the App.
	RiskControls *RiskControls `json:"riskControls,omitempty"`
}

AppSecurity Security controls applied to App traffic.

type Assignments

type Assignments struct {
	// Inclusion rules controlling who can access the App.
	Inclusions AssignmentsInclusions `json:"inclusions"`
}

Assignments User/group assignment rules for an App.

type AssignmentsInclusions

type AssignmentsInclusions struct {
	// `true` grants access to all users; `groups` array is then ignored.
	AllUsers bool `json:"allUsers"`
	// Device Group IDs (from the Device Groups API). Used when `allUsers` is `false`. When `allUsers:
	// false`, at least one group ID must be supplied — an empty `groups` array returns `400`.
	Groups *[]string `json:"groups,omitempty"`
}

AssignmentsInclusions Inclusion rules controlling who can access the App. Correction to the `groups` description above: `allUsers: false` with an empty `groups` array does **not** return `400`. It is accepted with `201`, producing an app assigned to no group at all (wire-verified 2026-08-30). Tenants hold apps in exactly this state, so a client decoding an app must tolerate it rather than treat it as impossible.

type BulkDeleteActivationProfilesRequest

type BulkDeleteActivationProfilesRequest struct {
	// Codes of the activation profiles to delete.
	Codes []string `json:"codes"`
}

BulkDeleteActivationProfilesRequest Request body for bulk-deleting activation profiles by code. `codes` is bounded at 1..100 and the bound is enforced as `400 INVALID_FIELD` on `codes` (`size must be between 1 and 100`) — for an empty array, for an absent `codes` key, and at 101 entries. `uniqueItems` is not enforced: a repeated code is accepted and answers 204. The operation answers 204 in every non-validation case, including a code that does not exist and a code already deleted, and returns no body — so there is no per-code result and no way to distinguish a delete that took from one the server silently skipped. Combined with the soft-delete behaviour noted on ActivationProfile, a successful call is not evidence that anything was deleted. Wire-verified 2026-09-01.

type Category

type Category struct {
	// Human-readable label (e.g. `"Social"`). This is the value to pass as `categoryName` when creating or
	// updating an App — TRS validates `categoryName` against this field via
	// `ContentBlockServiceClient.getCategories()` which maps `Category::getDisplayName`.
	DisplayName string `json:"displayName"`
	// Unique category identifier.
	ID string `json:"id"`
	// Internal category name (e.g. `Category - Social`). Informational only — do not use as
	// `categoryName`; use `displayName`, which TRS validates against.
	Name string `json:"name"`
}

Category A content category from `content-block-service`. Use `displayName` as `categoryName` when creating or updating an App — TRS validates against `displayName`, not `name`.

type CategoryListResponse

type CategoryListResponse struct {
	Results []Category `json:"results"`
	// Total number of content categories.
	TotalCount int `json:"totalCount"`
}

CategoryListResponse Full list of content categories. Not paginated; the same list is returned for all tenants.

type CategoryName

type CategoryName = string

CategoryName is an alias for string.

type CipherSuiteConfig

type CipherSuiteConfig struct {
	// Diffie-Hellman group. Exactly one value.
	// Allowed values: see the CipherSuiteConfigDhGroups constants.
	DhGroups []string `json:"dhGroups"`
	// Encryption algorithm. Exactly one value.
	// Allowed values: see the CipherSuiteConfigEncryption constants.
	Encryption []string `json:"encryption"`
	// Integrity algorithm. Exactly one value.
	// Allowed values: see the CipherSuiteConfigIntegrity constants.
	Integrity []string `json:"integrity"`
	// Key lifetime in seconds (e.g. `28800` for IKE, `3600` for ESP).
	LifetimeInSec int64 `json:"lifetimeInSec"`
}

CipherSuiteConfig Cipher suite configuration for an IKE or ESP phase.

type CipherSuiteConfigDhGroups

type CipherSuiteConfigDhGroups = string

CipherSuiteConfigDhGroups is the set of values accepted by CipherSuiteConfig.DhGroups.

const (
	CipherSuiteConfigDhGroupsModp1024 CipherSuiteConfigDhGroups = "modp1024"
	CipherSuiteConfigDhGroupsModp1536 CipherSuiteConfigDhGroups = "modp1536"
	CipherSuiteConfigDhGroupsModp2048 CipherSuiteConfigDhGroups = "modp2048"
	CipherSuiteConfigDhGroupsModp3072 CipherSuiteConfigDhGroups = "modp3072"
	CipherSuiteConfigDhGroupsModp4096 CipherSuiteConfigDhGroups = "modp4096"
	CipherSuiteConfigDhGroupsEcp256   CipherSuiteConfigDhGroups = "ecp256"
	CipherSuiteConfigDhGroupsEcp384   CipherSuiteConfigDhGroups = "ecp384"
	CipherSuiteConfigDhGroupsEcp521   CipherSuiteConfigDhGroups = "ecp521"
)

CipherSuiteConfigDhGroups values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func CipherSuiteConfigDhGroupsValues

func CipherSuiteConfigDhGroupsValues() []CipherSuiteConfigDhGroups

CipherSuiteConfigDhGroupsValues returns every value the Jamf API accepts for CipherSuiteConfigDhGroups, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type CipherSuiteConfigEncryption

type CipherSuiteConfigEncryption = string

CipherSuiteConfigEncryption is the set of values accepted by CipherSuiteConfig.Encryption.

const (
	CipherSuiteConfigEncryption3des   CipherSuiteConfigEncryption = "3des"
	CipherSuiteConfigEncryptionAes128 CipherSuiteConfigEncryption = "aes128"
	CipherSuiteConfigEncryptionAes256 CipherSuiteConfigEncryption = "aes256"
)

CipherSuiteConfigEncryption values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func CipherSuiteConfigEncryptionValues

func CipherSuiteConfigEncryptionValues() []CipherSuiteConfigEncryption

CipherSuiteConfigEncryptionValues returns every value the Jamf API accepts for CipherSuiteConfigEncryption, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type CipherSuiteConfigIntegrity

type CipherSuiteConfigIntegrity = string

CipherSuiteConfigIntegrity is the set of values accepted by CipherSuiteConfig.Integrity.

const (
	CipherSuiteConfigIntegrityMd5    CipherSuiteConfigIntegrity = "md5"
	CipherSuiteConfigIntegritySha1   CipherSuiteConfigIntegrity = "sha1"
	CipherSuiteConfigIntegritySha256 CipherSuiteConfigIntegrity = "sha256"
	CipherSuiteConfigIntegritySha512 CipherSuiteConfigIntegrity = "sha512"
)

CipherSuiteConfigIntegrity values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func CipherSuiteConfigIntegrityValues

func CipherSuiteConfigIntegrityValues() []CipherSuiteConfigIntegrity

CipherSuiteConfigIntegrityValues returns every value the Jamf API accepts for CipherSuiteConfigIntegrity, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type CitrixCloudConfig

type CitrixCloudConfig struct {
	// Citrix Cloud API client (application) id.
	ApplicationID string `json:"applicationId"`
	// Citrix Cloud API client secret.
	// Write-only. Servers MUST NOT return this field in responses; the SDK preserves it only so the caller
	// can supply a value on update.
	ApplicationSecret string `json:"applicationSecret"`
	// Citrix Cloud customer id.
	CustomerID string `json:"customerId"`
	// Citrix Cloud API URL.
	URL string `json:"url"`
}

CitrixCloudConfig Citrix Cloud administrator credentials for the CITRIX_CLOUD_ADMIN strategy.

type CitrixCloudOauthConfig

type CitrixCloudOauthConfig struct {
	// Citrix Cloud API client (application) id.
	ApplicationID string `json:"applicationId"`
	// Citrix Cloud API client secret.
	// Write-only. Servers MUST NOT return this field in responses; the SDK preserves it only so the caller
	// can supply a value on update.
	ApplicationSecret string `json:"applicationSecret"`
	// Citrix Cloud customer id.
	CustomerID string `json:"customerId"`
	// Citrix Cloud region — determines the API endpoint.
	// Allowed values: see the CitrixCloudOauthConfigRegion constants.
	Region string `json:"region"`
}

CitrixCloudOauthConfig Citrix Cloud OAuth credentials for the CITRIX_CLOUD_ADMIN_OAUTH strategy.

type CitrixCloudOauthConfigRegion

type CitrixCloudOauthConfigRegion = string

CitrixCloudOauthConfigRegion is the set of values accepted by CitrixCloudOauthConfig.Region.

const (
	CitrixCloudOauthConfigRegionAsiaPacific CitrixCloudOauthConfigRegion = "ASIA_PACIFIC"
	CitrixCloudOauthConfigRegionEu          CitrixCloudOauthConfigRegion = "EU"
	CitrixCloudOauthConfigRegionUsa         CitrixCloudOauthConfigRegion = "USA"
	CitrixCloudOauthConfigRegionJapan       CitrixCloudOauthConfigRegion = "JAPAN"
)

CitrixCloudOauthConfigRegion values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func CitrixCloudOauthConfigRegionValues

func CitrixCloudOauthConfigRegionValues() []CitrixCloudOauthConfigRegion

CitrixCloudOauthConfigRegionValues returns every value the Jamf API accepts for CitrixCloudOauthConfigRegion, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type Client

type Client struct {
	// contains filtered or unexported fields
}

Client provides typed methods for securitycloud operations.

func New

func New(base *jamfplatform.Client) *Client

New creates a securitycloud client that shares the authenticated transport of the given root client.

func (*Client) ApplyDeviceGroupV2

func (c *Client) ApplyDeviceGroupV2(ctx context.Context, request *CreateGroupRequest) (string, bool, error)

ApplyDeviceGroupV2 creates or updates a DeviceGroupV2 by name. If a resource with the specified name exists, it is updated; if not found, a new resource is created. Returns the resource ID, whether it was created (true) or updated (false), and any error. An *AmbiguousMatchError is returned if multiple resources match the name.

func (*Client) ApplyDnsZoneV1

func (c *Client) ApplyDnsZoneV1(ctx context.Context, request *ZoneWrite) (string, bool, error)

ApplyDnsZoneV1 creates or updates a DnsZoneV1 by name. If a resource with the specified name exists, it is updated; if not found, a new resource is created. Returns the resource ID, whether it was created (true) or updated (false), and any error. An *AmbiguousMatchError is returned if multiple resources match the name.

func (*Client) ApplyZtnaAppV1

func (c *Client) ApplyZtnaAppV1(ctx context.Context, request *AppCreateRequest) (string, bool, error)

ApplyZtnaAppV1 creates or updates a ZtnaAppV1 by name. If a resource with the specified name exists, it is updated; if not found, a new resource is created. Returns the resource ID, whether it was created (true) or updated (false), and any error. An *AmbiguousMatchError is returned if multiple resources match the name.

func (*Client) ApplyZtnaGatewayV1

func (c *Client) ApplyZtnaGatewayV1(ctx context.Context, request *GatewayCreateRequest) (string, bool, error)

ApplyZtnaGatewayV1 creates or updates a ZtnaGatewayV1 by name. If a resource with the specified name exists, it is updated; if not found, a new resource is created. Returns the resource ID, whether it was created (true) or updated (false), and any error. An *AmbiguousMatchError is returned if multiple resources match the name.

func (*Client) ApplyZtnaGroupedGatewayV1

func (c *Client) ApplyZtnaGroupedGatewayV1(ctx context.Context, request *GroupedGatewayCreateRequest) (string, bool, error)

ApplyZtnaGroupedGatewayV1 creates or updates a ZtnaGroupedGatewayV1 by name. If a resource with the specified name exists, it is updated; if not found, a new resource is created. Returns the resource ID, whether it was created (true) or updated (false), and any error. An *AmbiguousMatchError is returned if multiple resources match the name.

func (*Client) CancelUemConnectorSyncV1

func (c *Client) CancelUemConnectorSyncV1(ctx context.Context, configID string) error

CancelUemConnectorSyncV1 cancel current sync run.

Required privileges: uem-connect:update.

Parameters:

  • configID: The connector configuration identifier.

func (*Client) ClearDnsCustomHostnameMappingsV1

func (c *Client) ClearDnsCustomHostnameMappingsV1(ctx context.Context) error

ClearDnsCustomHostnameMappingsV1 clear Custom Hostname Mappings.

Required privileges: custom-hostname-mappings:delete.

func (*Client) ClearDnsSearchDomainV1

func (c *Client) ClearDnsSearchDomainV1(ctx context.Context) error

ClearDnsSearchDomainV1 clear the Search Domain.

Required privileges: search-domains:delete.

func (*Client) CreateActivationProfileV1

func (c *Client) CreateActivationProfileV1(ctx context.Context, request *PublicApiCreateActivationProfileRequest) (*ActivationProfile, error)

CreateActivationProfileV1 create activation profile.

Required privileges: activation-profiles:create.

func (*Client) CreateDeviceGroupV1

func (c *Client) CreateDeviceGroupV1(ctx context.Context, request *CreateGroupRequest) (*Group, error)

CreateDeviceGroupV1 create a new device group.

Required privileges: device-groups:create.

func (*Client) CreateDnsZoneV1

func (c *Client) CreateDnsZoneV1(ctx context.Context, request *ZoneWrite) (*ZoneRef, error)

CreateDnsZoneV1 create a DNS Zone.

Required privileges: ztna:create.

func (*Client) CreateUemConnectorV1

func (c *Client) CreateUemConnectorV1(ctx context.Context, request *ConnectorCreateRequestBody) (*CreatedResource, error)

CreateUemConnectorV1 create connector.

Required privileges: uem-connect:create.

func (*Client) CreateZtnaAppV1

func (c *Client) CreateZtnaAppV1(ctx context.Context, request *AppCreateRequest) (*CreateResponse, error)

CreateZtnaAppV1 create an App.

Required privileges: ztna:create.

func (*Client) CreateZtnaGatewayV1

func (c *Client) CreateZtnaGatewayV1(ctx context.Context, request *GatewayCreateRequest) (*CreateResponse, error)

CreateZtnaGatewayV1 create a Gateway.

Required privileges: ztna:create.

func (*Client) CreateZtnaGroupedGatewayV1

func (c *Client) CreateZtnaGroupedGatewayV1(ctx context.Context, request *GroupedGatewayCreateRequest) (*CreateResponse, error)

CreateZtnaGroupedGatewayV1 create a Grouped Gateway.

Required privileges: ztna:create.

func (*Client) DeleteActivationProfilesV1

func (c *Client) DeleteActivationProfilesV1(ctx context.Context, request *BulkDeleteActivationProfilesRequest) error

DeleteActivationProfilesV1 delete multiple activation profiles.

Required privileges: activation-profiles:delete.

func (*Client) DeleteDeviceGroupV1

func (c *Client) DeleteDeviceGroupV1(ctx context.Context, groupID string) error

DeleteDeviceGroupV1 delete a device group.

Required privileges: device-groups:delete.

Parameters:

  • groupID: Unique identifier of the group to delete.

func (*Client) DeleteDnsZoneV1

func (c *Client) DeleteDnsZoneV1(ctx context.Context, id string) error

DeleteDnsZoneV1 delete a DNS Zone.

Required privileges: ztna:delete.

Parameters:

  • id: Identifier of the DNS Zone to operate on.

func (*Client) DeleteUemConnectorV1

func (c *Client) DeleteUemConnectorV1(ctx context.Context, configID string) error

DeleteUemConnectorV1 delete connector.

Required privileges: uem-connect:delete.

Parameters:

  • configID: The connector configuration identifier.

func (*Client) DeleteZtnaAppV1

func (c *Client) DeleteZtnaAppV1(ctx context.Context, appID string) error

DeleteZtnaAppV1 delete an App.

Required privileges: ztna:delete.

Parameters:

  • appID: ID of the App (Access Policy). Format: UUID (e.g. `3fa85f64-5717-4562-b3fc-2c963f66afa6`).

func (*Client) DeleteZtnaGatewayV1

func (c *Client) DeleteZtnaGatewayV1(ctx context.Context, gatewayID string) error

DeleteZtnaGatewayV1 delete a Gateway.

Required privileges: ztna:delete.

Parameters:

  • gatewayID: ID of the Gateway (obtained from `GET /gateways` or a create response). Format: 4-character lowercase hexadecimal string (e.g. `a1b2`).

func (*Client) DeleteZtnaGroupedGatewayV1

func (c *Client) DeleteZtnaGroupedGatewayV1(ctx context.Context, groupedGatewayID string) error

DeleteZtnaGroupedGatewayV1 delete a Grouped Gateway.

Required privileges: ztna:delete.

Parameters:

  • groupedGatewayID: ID of the Grouped Gateway. Format: UUID (e.g. `3fa85f64-5717-4562-b3fc-2c963f66afa6`).

func (*Client) DeployActivationProfileToUemV1

func (c *Client) DeployActivationProfileToUemV1(ctx context.Context, code string, request *ActivationProfileDeployRequest) error

DeployActivationProfileToUemV1 deploy Jamf Security configuration profiles to UEM.

Required privileges: uem-connect:update.

Parameters:

  • code: The activation profile code obtained from the Jamf Security setup flow.

func (*Client) DisableUemConnectorV1

func (c *Client) DisableUemConnectorV1(ctx context.Context, configID string) error

DisableUemConnectorV1 disable connector synchronization.

Required privileges: uem-connect:delete.

Parameters:

  • configID: The connector configuration identifier.

func (*Client) EnableUemConnectorV1

func (c *Client) EnableUemConnectorV1(ctx context.Context, configID string, request *EnablementRequest) error

EnableUemConnectorV1 enable connector synchronization.

Required privileges: uem-connect:update.

Parameters:

  • configID: The connector configuration identifier.

func (*Client) GetActivationProfileV1

func (c *Client) GetActivationProfileV1(ctx context.Context, activationProfileID string) (*ActivationProfile, error)

GetActivationProfileV1 get activation profile.

Required privileges: activation-profiles:read.

Parameters:

  • activationProfileID: Unique code identifying the activation profile.

func (*Client) GetDeviceGroupV1

func (c *Client) GetDeviceGroupV1(ctx context.Context, groupID string) (*Group, error)

GetDeviceGroupV1 get a device group by ID.

Required privileges: device-groups:read.

Parameters:

  • groupID: Unique identifier of the group to retrieve.

func (*Client) GetDnsCustomHostnameMappingsV1

func (c *Client) GetDnsCustomHostnameMappingsV1(ctx context.Context) (*MappingList, error)

GetDnsCustomHostnameMappingsV1 get Custom Hostname Mappings.

Required privileges: custom-hostname-mappings:read.

func (*Client) GetDnsSearchDomainV1

func (c *Client) GetDnsSearchDomainV1(ctx context.Context) (*SearchDomain, error)

GetDnsSearchDomainV1 get the Search Domain.

Required privileges: search-domains:read.

func (*Client) GetDnsZoneV1

func (c *Client) GetDnsZoneV1(ctx context.Context, id string) (*Zone, error)

GetDnsZoneV1 get a DNS Zone.

Required privileges: ztna:read.

Parameters:

  • id: Identifier of the DNS Zone to operate on.

func (*Client) GetUemConnectorSyncSettingsV1

func (c *Client) GetUemConnectorSyncSettingsV1(ctx context.Context, configID string) (*ConnectorConfig, error)

GetUemConnectorSyncSettingsV1 get connector sync settings.

Required privileges: uem-connect:read.

Parameters:

  • configID: The connector configuration identifier.

func (*Client) GetUemConnectorV1

func (c *Client) GetUemConnectorV1(ctx context.Context, configID string) (*ConnectorConfig, error)

GetUemConnectorV1 get connector.

Required privileges: uem-connect:read.

Parameters:

  • configID: The connector configuration identifier.

func (*Client) GetZtnaAppV1

func (c *Client) GetZtnaAppV1(ctx context.Context, appID string) (*App, error)

GetZtnaAppV1 get an App.

Required privileges: ztna:read.

Parameters:

  • appID: ID of the App (Access Policy). Format: UUID (e.g. `3fa85f64-5717-4562-b3fc-2c963f66afa6`).

func (*Client) GetZtnaGatewayV1

func (c *Client) GetZtnaGatewayV1(ctx context.Context, gatewayID string) (*Gateway, error)

GetZtnaGatewayV1 get a Gateway.

Required privileges: ztna:read.

Parameters:

  • gatewayID: ID of the Gateway (obtained from `GET /gateways` or a create response). Format: 4-character lowercase hexadecimal string (e.g. `a1b2`).

func (*Client) GetZtnaGroupedGatewayV1

func (c *Client) GetZtnaGroupedGatewayV1(ctx context.Context, groupedGatewayID string) (*GroupedGateway, error)

GetZtnaGroupedGatewayV1 get a Grouped Gateway.

Required privileges: ztna:read.

Parameters:

  • groupedGatewayID: ID of the Grouped Gateway. Format: UUID (e.g. `3fa85f64-5717-4562-b3fc-2c963f66afa6`).

func (*Client) ListActivationProfilesV1

func (c *Client) ListActivationProfilesV1(ctx context.Context, origin string) (*ActivationProfilesResponse, error)

ListActivationProfilesV1 search activation profiles.

Required privileges: activation-profiles:read.

Parameters:

  • origin: Creation origin - the feature or context that created the activation profile. Allowed values: "PUBLIC_API".

func (*Client) ListContentCategoriesV1

func (c *Client) ListContentCategoriesV1(ctx context.Context) (*CategoryListResponse, error)

ListContentCategoriesV1 list Categories.

Required privileges: content-categories:read.

func (*Client) ListDeviceGroupsV2

func (c *Client) ListDeviceGroupsV2(ctx context.Context) (*GroupListResponseV2, error)

ListDeviceGroupsV2 list all device groups for a customer.

Required privileges: device-groups:read.

func (*Client) ListDnsZonesV1

func (c *Client) ListDnsZonesV1(ctx context.Context, sort string) (*ZoneList, error)

ListDnsZonesV1 list DNS Zones.

Required privileges: ztna:read.

Parameters:

  • sort: Sort expression in the form `field:direction`, where direction is `asc` or `desc`. Defaults to ascending order when direction is omitted. The only supported sort field is `name`. Allowed values: "name:asc", "name:desc", "name".

func (*Client) ListUemConnectorSyncRunsV1

func (c *Client) ListUemConnectorSyncRunsV1(ctx context.Context, configID string) ([]SyncRun, error)

ListUemConnectorSyncRunsV1 list sync run history.

Required privileges: uem-connect:read.

Parameters:

  • configID: The connector configuration identifier.

func (*Client) ListUemConnectorsV1

func (c *Client) ListUemConnectorsV1(ctx context.Context) (*ConnectorPage, error)

ListUemConnectorsV1 list connectors.

Required privileges: uem-connect:read.

func (*Client) ListZtnaAppsV1

func (c *Client) ListZtnaAppsV1(ctx context.Context) ([]App, error)

ListZtnaAppsV1 list Apps.

Required privileges: ztna:read.

func (*Client) ListZtnaGatewaysV1

func (c *Client) ListZtnaGatewaysV1(ctx context.Context) (*GatewayListResponse, error)

ListZtnaGatewaysV1 list Gateways.

Required privileges: ztna:read.

func (*Client) ListZtnaGroupedGatewaysV1

func (c *Client) ListZtnaGroupedGatewaysV1(ctx context.Context) (*GroupedGatewayListResponse, error)

ListZtnaGroupedGatewaysV1 list Grouped Gateways.

Required privileges: ztna:read.

func (*Client) ListZtnaPredefinedAppsV1

func (c *Client) ListZtnaPredefinedAppsV1(ctx context.Context) (*PredefinedAppListResponse, error)

ListZtnaPredefinedAppsV1 list Predefined Apps.

Required privileges: ztna:read.

func (*Client) ListZtnaSharedGatewaysV1

func (c *Client) ListZtnaSharedGatewaysV1(ctx context.Context) (*SharedGatewayListResponse, error)

ListZtnaSharedGatewaysV1 list Shared Gateways.

Required privileges: ztna:read.

func (*Client) PauseActivationProfileV1

func (c *Client) PauseActivationProfileV1(ctx context.Context, activationProfileID string) error

PauseActivationProfileV1 pause activation profile.

Required privileges: activation-profiles:update.

Parameters:

  • activationProfileID: Unique code identifying the activation profile.

func (*Client) ReplaceDnsCustomHostnameMappingsV1

func (c *Client) ReplaceDnsCustomHostnameMappingsV1(ctx context.Context, request *[]Mapping) error

ReplaceDnsCustomHostnameMappingsV1 replace Custom Hostname Mappings.

Required privileges: custom-hostname-mappings:update.

func (*Client) ResolveContentCategoryV1ByName

func (c *Client) ResolveContentCategoryV1ByName(ctx context.Context, name string) (*Category, error)

ResolveContentCategoryV1ByName looks up a ContentCategoryV1 by its displayName field and returns the decoded resource. Shares the same HTTP call as the ID-only variant; error semantics are identical.

func (*Client) ResolveContentCategoryV1IDByName

func (c *Client) ResolveContentCategoryV1IDByName(ctx context.Context, name string) (string, error)

ResolveContentCategoryV1IDByName looks up a ContentCategoryV1 by its displayName field and returns the ID. Returns *APIResponseError with HasStatus(404) when no match exists, or *AmbiguousMatchError when multiple resources share the name.

func (*Client) ResolveDeviceGroupV2ByName

func (c *Client) ResolveDeviceGroupV2ByName(ctx context.Context, name string) (*GroupListItem, error)

ResolveDeviceGroupV2ByName looks up a DeviceGroupV2 by its name field and returns the decoded resource. Shares the same HTTP call as the ID-only variant; error semantics are identical.

func (*Client) ResolveDeviceGroupV2IDByName

func (c *Client) ResolveDeviceGroupV2IDByName(ctx context.Context, name string) (string, error)

ResolveDeviceGroupV2IDByName looks up a DeviceGroupV2 by its name field and returns the ID. Returns *APIResponseError with HasStatus(404) when no match exists, or *AmbiguousMatchError when multiple resources share the name.

func (*Client) ResolveDnsZoneV1ByName

func (c *Client) ResolveDnsZoneV1ByName(ctx context.Context, name string) (*Zone, error)

ResolveDnsZoneV1ByName looks up a DnsZoneV1 by its name field and returns the decoded resource. Shares the same HTTP call as the ID-only variant; error semantics are identical.

func (*Client) ResolveDnsZoneV1IDByName

func (c *Client) ResolveDnsZoneV1IDByName(ctx context.Context, name string) (string, error)

ResolveDnsZoneV1IDByName looks up a DnsZoneV1 by its name field and returns the ID. Returns *APIResponseError with HasStatus(404) when no match exists, or *AmbiguousMatchError when multiple resources share the name.

func (*Client) ResolveZtnaAppV1ByName

func (c *Client) ResolveZtnaAppV1ByName(ctx context.Context, name string) (*App, error)

ResolveZtnaAppV1ByName looks up a ZtnaAppV1 by its name field and returns the decoded resource. Shares the same HTTP call as the ID-only variant; error semantics are identical.

func (*Client) ResolveZtnaAppV1IDByName

func (c *Client) ResolveZtnaAppV1IDByName(ctx context.Context, name string) (string, error)

ResolveZtnaAppV1IDByName looks up a ZtnaAppV1 by its name field and returns the ID. Returns *APIResponseError with HasStatus(404) when no match exists, or *AmbiguousMatchError when multiple resources share the name.

func (*Client) ResolveZtnaGatewayV1ByName

func (c *Client) ResolveZtnaGatewayV1ByName(ctx context.Context, name string) (*Gateway, error)

ResolveZtnaGatewayV1ByName looks up a ZtnaGatewayV1 by its name field and returns the decoded resource. Shares the same HTTP call as the ID-only variant; error semantics are identical.

func (*Client) ResolveZtnaGatewayV1IDByName

func (c *Client) ResolveZtnaGatewayV1IDByName(ctx context.Context, name string) (string, error)

ResolveZtnaGatewayV1IDByName looks up a ZtnaGatewayV1 by its name field and returns the ID. Returns *APIResponseError with HasStatus(404) when no match exists, or *AmbiguousMatchError when multiple resources share the name.

func (*Client) ResolveZtnaGroupedGatewayV1ByName

func (c *Client) ResolveZtnaGroupedGatewayV1ByName(ctx context.Context, name string) (*GroupedGateway, error)

ResolveZtnaGroupedGatewayV1ByName looks up a ZtnaGroupedGatewayV1 by its name field and returns the decoded resource. Shares the same HTTP call as the ID-only variant; error semantics are identical.

func (*Client) ResolveZtnaGroupedGatewayV1IDByName

func (c *Client) ResolveZtnaGroupedGatewayV1IDByName(ctx context.Context, name string) (string, error)

ResolveZtnaGroupedGatewayV1IDByName looks up a ZtnaGroupedGatewayV1 by its name field and returns the ID. Returns *APIResponseError with HasStatus(404) when no match exists, or *AmbiguousMatchError when multiple resources share the name.

func (*Client) ResumeActivationProfileV1

func (c *Client) ResumeActivationProfileV1(ctx context.Context, activationProfileID string) error

ResumeActivationProfileV1 resume activation profile.

Required privileges: activation-profiles:update.

Parameters:

  • activationProfileID: Unique code identifying the activation profile.

func (*Client) SetDnsSearchDomainV1

func (c *Client) SetDnsSearchDomainV1(ctx context.Context, request *SearchDomain) error

SetDnsSearchDomainV1 set the Search Domain.

Required privileges: search-domains:update.

func (*Client) TriggerUemConnectorSyncV1

func (c *Client) TriggerUemConnectorSyncV1(ctx context.Context, configID string) error

TriggerUemConnectorSyncV1 trigger sync run.

Required privileges: uem-connect:update.

Parameters:

  • configID: The connector configuration identifier.

func (*Client) UpdateDeviceGroupV2

func (c *Client) UpdateDeviceGroupV2(ctx context.Context, groupID string, request *UpdateGroupRequest) error

UpdateDeviceGroupV2 update a device group.

Required privileges: device-groups:update.

Parameters:

  • groupID: Unique identifier of the group to update.

func (*Client) UpdateDnsZoneV1

func (c *Client) UpdateDnsZoneV1(ctx context.Context, id string, request *ZonePatch) error

UpdateDnsZoneV1 update a DNS Zone.

Required privileges: ztna:update.

Parameters:

  • id: Identifier of the DNS Zone to operate on.

func (*Client) UpdateUemConnectorSyncSettingsV1

func (c *Client) UpdateUemConnectorSyncSettingsV1(ctx context.Context, configID string, request *SyncSettings) error

UpdateUemConnectorSyncSettingsV1 update connector sync settings.

Required privileges: uem-connect:update.

Parameters:

  • configID: The connector configuration identifier.

func (*Client) UpdateZtnaAppV1

func (c *Client) UpdateZtnaAppV1(ctx context.Context, appID string, request *AppPatchRequest) error

UpdateZtnaAppV1 partially update an App.

Required privileges: ztna:update.

Parameters:

  • appID: ID of the App (Access Policy). Format: UUID (e.g. `3fa85f64-5717-4562-b3fc-2c963f66afa6`).

func (*Client) UpdateZtnaGatewayV1

func (c *Client) UpdateZtnaGatewayV1(ctx context.Context, gatewayID string, request *GatewayPatchRequest) error

UpdateZtnaGatewayV1 partially update a Gateway.

Required privileges: ztna:update.

Parameters:

  • gatewayID: ID of the Gateway (obtained from `GET /gateways` or a create response). Format: 4-character lowercase hexadecimal string (e.g. `a1b2`).

func (*Client) UpdateZtnaGroupedGatewayV1

func (c *Client) UpdateZtnaGroupedGatewayV1(ctx context.Context, groupedGatewayID string, request *GroupedGatewayPatchRequest) error

UpdateZtnaGroupedGatewayV1 partially update a Grouped Gateway.

Required privileges: ztna:update.

Parameters:

  • groupedGatewayID: ID of the Grouped Gateway. Format: UUID (e.g. `3fa85f64-5717-4562-b3fc-2c963f66afa6`).

type ConnectionConfigLeftRequest

type ConnectionConfigLeftRequest struct {
	// Endpoint address or `%any`.
	Host string `json:"host"`
	// IKE identity (e.g. `wpa.wandera.com` or `%any`).
	ID string `json:"id"`
	// Pre-shared key. Provide to set or rotate the secret. Omit to preserve the existing secret on PATCH
	// — it can only be rotated, never cleared. Sending `null` explicitly returns `400
	// IPSEC_SECRET_CLEAR_NOT_SUPPORTED`.
	// Write-only. Servers MUST NOT return this field in responses; the SDK preserves it only so the caller
	// can supply a value on update.
	Secret *string `json:"secret,omitempty"`
	// Jamf-side encryption domain. Must be a private (RFC1918) CIDR in one of the ranges above. Exactly 1
	// element.
	Subnets []string `json:"subnets"`
}

ConnectionConfigLeftRequest IPSec connection endpoint for write requests. Includes the `secret` field. `secret` is write-only — it is never returned in GET responses.

type ConnectionConfigLeftResponse

type ConnectionConfigLeftResponse struct {
	// Authentication method.
	// Allowed values: see the ConnectionConfigLeftResponseAuth constants.
	Auth string `json:"auth"`
	// Endpoint address.
	Host string `json:"host"`
	// IKE identity.
	ID string `json:"id"`
	// CIDR subnets.
	Subnets []string `json:"subnets"`
}

ConnectionConfigLeftResponse IPSec Jamf-side endpoint returned on GET. Secrets are never included.

type ConnectionConfigLeftResponseAuth

type ConnectionConfigLeftResponseAuth = string

ConnectionConfigLeftResponseAuth is the set of values accepted by ConnectionConfigLeftResponse.Auth.

const (
	ConnectionConfigLeftResponseAuthPsk ConnectionConfigLeftResponseAuth = "psk"
)

ConnectionConfigLeftResponseAuth values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func ConnectionConfigLeftResponseAuthValues

func ConnectionConfigLeftResponseAuthValues() []ConnectionConfigLeftResponseAuth

ConnectionConfigLeftResponseAuthValues returns every value the Jamf API accepts for ConnectionConfigLeftResponseAuth, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type ConnectionConfigPatchLeftRequest

type ConnectionConfigPatchLeftRequest struct {
	// Endpoint address or `%any`.
	Host *string `json:"host,omitempty"`
	// IKE identity (e.g. `wpa.wandera.com` or `%any`).
	ID *string `json:"id,omitempty"`
	// Pre-shared key. Provide to set or rotate the PSK. Omit to preserve the existing secret. Sending
	// `null` returns `400 IPSEC_SECRET_CLEAR_NOT_SUPPORTED`.
	// Write-only. Servers MUST NOT return this field in responses; the SDK preserves it only so the caller
	// can supply a value on update.
	Secret *string `json:"secret,omitempty"`
	// Jamf-side encryption domain. Must be a private (RFC1918) CIDR in one of the ranges above. Exactly 1
	// element.
	Subnets *[]string `json:"subnets,omitempty"`
}

ConnectionConfigPatchLeftRequest IPSec connection endpoint for PATCH `left`. All fields optional — supply only the fields to update. `secret` is write-only; omit to preserve the existing PSK; sending `null` returns `400 IPSEC_SECRET_CLEAR_NOT_SUPPORTED`.

type ConnectionConfigPatchRightRequest

type ConnectionConfigPatchRightRequest struct {
	// Endpoint address or `%any`.
	Host *string `json:"host,omitempty"`
	// IKE identity (e.g. `wpa.wandera.com` or `%any`).
	ID *string `json:"id,omitempty"`
	// CIDR subnets routed through this endpoint.
	Subnets *[]string `json:"subnets,omitempty"`
	// VPN vendor identifier of the remote peer. Case-sensitive.
	// Allowed values: see the ConnectionConfigPatchRightRequestVendor constants.
	Vendor *string `json:"vendor,omitempty"`
}

ConnectionConfigPatchRightRequest IPSec connection endpoint for PATCH `right` (remote peer). The secret is always derived from `left.secret` — callers never supply it here.

type ConnectionConfigPatchRightRequestVendor

type ConnectionConfigPatchRightRequestVendor = string

ConnectionConfigPatchRightRequestVendor is the set of values accepted by ConnectionConfigPatchRightRequest.Vendor.

const (
	ConnectionConfigPatchRightRequestVendorCheckpoint ConnectionConfigPatchRightRequestVendor = "Checkpoint"
	ConnectionConfigPatchRightRequestVendorCisco      ConnectionConfigPatchRightRequestVendor = "Cisco"
	ConnectionConfigPatchRightRequestVendorFortinet   ConnectionConfigPatchRightRequestVendor = "Fortinet"
	ConnectionConfigPatchRightRequestVendorJuniper    ConnectionConfigPatchRightRequestVendor = "Juniper"
	ConnectionConfigPatchRightRequestVendorPaloAlto   ConnectionConfigPatchRightRequestVendor = "Palo Alto"
	ConnectionConfigPatchRightRequestVendorSonicWall  ConnectionConfigPatchRightRequestVendor = "SonicWall"
	ConnectionConfigPatchRightRequestVendorSophos     ConnectionConfigPatchRightRequestVendor = "Sophos"
	ConnectionConfigPatchRightRequestVendorSourcefire ConnectionConfigPatchRightRequestVendor = "Sourcefire"
	ConnectionConfigPatchRightRequestVendorStrongSwan ConnectionConfigPatchRightRequestVendor = "strongSwan"
	ConnectionConfigPatchRightRequestVendorWatchguard ConnectionConfigPatchRightRequestVendor = "Watchguard"
	ConnectionConfigPatchRightRequestVendorOther      ConnectionConfigPatchRightRequestVendor = "Other"
)

ConnectionConfigPatchRightRequestVendor values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func ConnectionConfigPatchRightRequestVendorValues

func ConnectionConfigPatchRightRequestVendorValues() []ConnectionConfigPatchRightRequestVendor

ConnectionConfigPatchRightRequestVendorValues returns every value the Jamf API accepts for ConnectionConfigPatchRightRequestVendor, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type ConnectionConfigRightRequest

type ConnectionConfigRightRequest struct {
	// Endpoint address.
	Host string `json:"host"`
	// IKE identity.
	ID string `json:"id"`
	// CIDR subnets routed through this endpoint (e.g. `0.0.0.0/0`).
	Subnets []string `json:"subnets"`
	// VPN vendor identifier of the remote peer. Case-sensitive. **Required**.
	// Allowed values: see the ConnectionConfigRightRequestVendor constants.
	Vendor string `json:"vendor"`
}

ConnectionConfigRightRequest IPSec connection endpoint for the `right` (remote peer) side. The secret is derived automatically from `left.secret` — callers never supply it here. `vendor` is **required** — use the peer's VPN vendor identifier (e.g. `cisco`, `strongSwan`, `juniper`).

type ConnectionConfigRightRequestVendor

type ConnectionConfigRightRequestVendor = string

ConnectionConfigRightRequestVendor is the set of values accepted by ConnectionConfigRightRequest.Vendor.

const (
	ConnectionConfigRightRequestVendorCheckpoint ConnectionConfigRightRequestVendor = "Checkpoint"
	ConnectionConfigRightRequestVendorCisco      ConnectionConfigRightRequestVendor = "Cisco"
	ConnectionConfigRightRequestVendorFortinet   ConnectionConfigRightRequestVendor = "Fortinet"
	ConnectionConfigRightRequestVendorJuniper    ConnectionConfigRightRequestVendor = "Juniper"
	ConnectionConfigRightRequestVendorPaloAlto   ConnectionConfigRightRequestVendor = "Palo Alto"
	ConnectionConfigRightRequestVendorSonicWall  ConnectionConfigRightRequestVendor = "SonicWall"
	ConnectionConfigRightRequestVendorSophos     ConnectionConfigRightRequestVendor = "Sophos"
	ConnectionConfigRightRequestVendorSourcefire ConnectionConfigRightRequestVendor = "Sourcefire"
	ConnectionConfigRightRequestVendorStrongSwan ConnectionConfigRightRequestVendor = "strongSwan"
	ConnectionConfigRightRequestVendorWatchguard ConnectionConfigRightRequestVendor = "Watchguard"
	ConnectionConfigRightRequestVendorOther      ConnectionConfigRightRequestVendor = "Other"
)

ConnectionConfigRightRequestVendor values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func ConnectionConfigRightRequestVendorValues

func ConnectionConfigRightRequestVendorValues() []ConnectionConfigRightRequestVendor

ConnectionConfigRightRequestVendorValues returns every value the Jamf API accepts for ConnectionConfigRightRequestVendor, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type ConnectionConfigRightResponse

type ConnectionConfigRightResponse struct {
	// Authentication method.
	// Allowed values: see the ConnectionConfigRightResponseAuth constants.
	Auth string `json:"auth"`
	// Endpoint address.
	Host string `json:"host"`
	// IKE identity.
	ID string `json:"id"`
	// CIDR subnets.
	Subnets []string `json:"subnets"`
	// VPN vendor identifier of the remote peer.
	// Allowed values: see the ConnectionConfigRightResponseVendor constants.
	Vendor string `json:"vendor"`
}

ConnectionConfigRightResponse IPSec remote-peer endpoint returned on GET. Secrets are never included.

type ConnectionConfigRightResponseAuth

type ConnectionConfigRightResponseAuth = string

ConnectionConfigRightResponseAuth is the set of values accepted by ConnectionConfigRightResponse.Auth.

const (
	ConnectionConfigRightResponseAuthPsk ConnectionConfigRightResponseAuth = "psk"
)

ConnectionConfigRightResponseAuth values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func ConnectionConfigRightResponseAuthValues

func ConnectionConfigRightResponseAuthValues() []ConnectionConfigRightResponseAuth

ConnectionConfigRightResponseAuthValues returns every value the Jamf API accepts for ConnectionConfigRightResponseAuth, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type ConnectionConfigRightResponseVendor

type ConnectionConfigRightResponseVendor = string

ConnectionConfigRightResponseVendor is the set of values accepted by ConnectionConfigRightResponse.Vendor.

const (
	ConnectionConfigRightResponseVendorCheckpoint ConnectionConfigRightResponseVendor = "Checkpoint"
	ConnectionConfigRightResponseVendorCisco      ConnectionConfigRightResponseVendor = "Cisco"
	ConnectionConfigRightResponseVendorFortinet   ConnectionConfigRightResponseVendor = "Fortinet"
	ConnectionConfigRightResponseVendorJuniper    ConnectionConfigRightResponseVendor = "Juniper"
	ConnectionConfigRightResponseVendorPaloAlto   ConnectionConfigRightResponseVendor = "Palo Alto"
	ConnectionConfigRightResponseVendorSonicWall  ConnectionConfigRightResponseVendor = "SonicWall"
	ConnectionConfigRightResponseVendorSophos     ConnectionConfigRightResponseVendor = "Sophos"
	ConnectionConfigRightResponseVendorSourcefire ConnectionConfigRightResponseVendor = "Sourcefire"
	ConnectionConfigRightResponseVendorStrongSwan ConnectionConfigRightResponseVendor = "strongSwan"
	ConnectionConfigRightResponseVendorWatchguard ConnectionConfigRightResponseVendor = "Watchguard"
	ConnectionConfigRightResponseVendorOther      ConnectionConfigRightResponseVendor = "Other"
)

ConnectionConfigRightResponseVendor values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func ConnectionConfigRightResponseVendorValues

func ConnectionConfigRightResponseVendorValues() []ConnectionConfigRightResponseVendor

ConnectionConfigRightResponseVendorValues returns every value the Jamf API accepts for ConnectionConfigRightResponseVendor, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type ConnectorConfig

type ConnectorConfig struct {
	// Whether this connector may sync concurrently with other connectors.
	ConcurrentSyncEnabled bool `json:"concurrentSyncEnabled"`
	// Whether the connector is currently connected to the UEM platform.
	Connected bool `json:"connected"`
	// Internal device-type discriminator for this connector's vendor.
	ConnectorDeviceTypeAlias string `json:"connectorDeviceTypeAlias"`
	// Identifier of the customer that owns this connector configuration.
	CustomerID string `json:"customerId"`
	// Controls which UEM attribute each JSC device field is populated from. Each value is an enum of UEM
	// attribute names whose members are vendor-specific, so the accepted values for a given key depend on
	// the connector's `vendor`. The Google connector accepts no mappings.
	DeviceFieldMappings *DeviceFieldMappings `json:"deviceFieldMappings,omitempty"`
	// Whether device risk levels are sent back to the UEM platform.
	DeviceRiskTagging bool `json:"deviceRiskTagging"`
	// Credentials the connector authenticates to the UEM instance with, as read back off a connector.
	// Restored from the wire (probed 2026-08-21, re-verified 2026-08-31) because the published spec omits
	// `deviceSyncAuth` from the *response* schema; the request side is upstream's own `JamfProCredentials`
	// as of v1882, which carries the same four members. Which of them apply depends on `authStrategy` —
	// OAuth strategies use `clientId`/`clientSecret`, basic-auth strategies use `username`/`password`.
	// Secrets are write-only and never returned; a read reports only `clientId`, `username` and an `empty`
	// flag, and for an `M2M`-provisioned connector the `clientId` is the one Jamf Security Cloud minted
	// for itself.
	DeviceSyncAuth *DeviceSyncAuth `json:"deviceSyncAuth,omitempty"`
	// Number of days since last check-in before a device is treated as unmanaged. `0` uses the platform
	// default (3 days). Not applicable for JAMF_PRO — any value sent for that vendor is silently ignored
	// (device status is taken exclusively from the UEM).
	// Allowed values: see the ConnectorConfigDeviceUnmanagedThreshold constants.
	DeviceUnmanagedThreshold int `json:"deviceUnmanagedThreshold"`
	// Whether the UEM platform supports receiving device tags from JSC.
	EmmTaggingSupported bool `json:"emmTaggingSupported"`
	// Whether the connector is enabled for synchronization.
	Enabled bool `json:"enabled"`
	// Group mapping configuration. Maps UEM groups to JSC groups.
	GroupSettings *GroupSettings `json:"groupSettings,omitempty"`
	// Unique identifier for the connector configuration.
	ID string `json:"id"`
	// ISO country code for the UEM instance, when applicable.
	IsoCountry *string `json:"isoCountry,omitempty"`
	// Summary of the connector's most recent sync run, embedded in `ConnectorConfig`. The containing
	// `latestSync` property is `null` until the connector has run its first sync.
	// This is **not** the same shape as the `SyncRun` entries returned by `GET
	// /connectors/{configId}/sync/runs`: it carries `lastSeen` and `errorDetails`, and has no per-run
	// device counters, because the connector record keeps only the current transaction's state and not its
	// tallies. Use the sync-runs endpoint for run history and counts.
	// `startedUtcMs` and `finishedUtcMs` are retained, deprecated epoch-millisecond duplicates of the
	// ISO-8601 `started` and `finished`. They are still emitted for existing consumers; new consumers
	// should read the ISO-8601 fields.
	LatestSync *LatestSync `json:"latestSync,omitempty"`
	// Timestamp of the next scheduled sync (ISO 8601).
	NextScheduledSync *time.Time `json:"nextScheduledSync,omitempty"`
	// Timestamp when the previous sync started (ISO 8601).
	PreviousSyncStart *time.Time `json:"previousSyncStart,omitempty"`
	// Sync refresh interval in minutes.
	// Allowed values: see the ConnectorConfigRefreshRateMinutes constants.
	RefreshRateMinutes int64 `json:"refreshRateMinutes"`
	// Whether scheduled sync is active.
	Scheduled bool `json:"scheduled"`
	// Sync configuration settings as returned in responses. Response-only: the corresponding update
	// request carries these two settings as **top-level** `autoDeviceDeletion` and
	// `disableSyncOnAuthError` fields on `SyncSettings`, not nested under `syncConfig`.
	SyncConfig *SyncConfig `json:"syncConfig,omitempty"`
	// Platform tenant identifier of the Jamf Pro instance this connector syncs with, when it was created
	// by naming one. Null for a connector created from caller-supplied credentials.
	// Load-bearing beyond information: `authStrategy` reads back as `JAMF_PRO_OAUTH` whichever way the
	// connector was created, so this field is the only thing in the response that distinguishes the two
	// forms. A consumer reconstructing a connector's configuration — Terraform importing one it did not
	// create, say — has nothing else to key on. Note that a tenant-named connector also reports a
	// `deviceSyncAuth.clientId`, the credential Jamf Security Cloud provisioned for itself, so the
	// presence of credentials cannot serve as the signal. Restored from the wire (probed 2026-08-28),
	// where the published spec omits it.
	TenantID *string `json:"tenantId"`
	// Version of the UEM instance the connector is talking to — for a Jamf Pro connector, the Jamf Pro
	// version. Reported by the connector rather than configured, and useful for surfacing what the
	// integration is actually connected to. Restored from the wire (probed 2026-08-28), where the
	// published spec omits it.
	UemVersion *string `json:"uemVersion"`
	// UEM server URL.
	URL string `json:"url"`
	// UEM vendor name.
	// Allowed values: see the ConnectorConfigVendor constants.
	Vendor string `json:"vendor"`
}

ConnectorConfig Connector configuration. Contains both core fields and vendor-specific fields. Additional vendor-specific properties may appear alongside the documented ones. Secret fields (credentials) are write-only and are never returned.

type ConnectorConfigDeviceUnmanagedThreshold

type ConnectorConfigDeviceUnmanagedThreshold = int

ConnectorConfigDeviceUnmanagedThreshold is the set of values accepted by ConnectorConfig.DeviceUnmanagedThreshold.

const (
	ConnectorConfigDeviceUnmanagedThreshold0  ConnectorConfigDeviceUnmanagedThreshold = 0
	ConnectorConfigDeviceUnmanagedThreshold1  ConnectorConfigDeviceUnmanagedThreshold = 1
	ConnectorConfigDeviceUnmanagedThreshold3  ConnectorConfigDeviceUnmanagedThreshold = 3
	ConnectorConfigDeviceUnmanagedThreshold5  ConnectorConfigDeviceUnmanagedThreshold = 5
	ConnectorConfigDeviceUnmanagedThreshold7  ConnectorConfigDeviceUnmanagedThreshold = 7
	ConnectorConfigDeviceUnmanagedThreshold14 ConnectorConfigDeviceUnmanagedThreshold = 14
)

ConnectorConfigDeviceUnmanagedThreshold values accepted by the Jamf API. The alias above is an int, so these constants pass to any parameter or field declared as a plain int.

func ConnectorConfigDeviceUnmanagedThresholdValues

func ConnectorConfigDeviceUnmanagedThresholdValues() []ConnectorConfigDeviceUnmanagedThreshold

ConnectorConfigDeviceUnmanagedThresholdValues returns every value the Jamf API accepts for ConnectorConfigDeviceUnmanagedThreshold, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's int64validator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type ConnectorConfigRefreshRateMinutes

type ConnectorConfigRefreshRateMinutes = int64

ConnectorConfigRefreshRateMinutes is the set of values accepted by ConnectorConfig.RefreshRateMinutes.

const (
	ConnectorConfigRefreshRateMinutes60   ConnectorConfigRefreshRateMinutes = 60
	ConnectorConfigRefreshRateMinutes120  ConnectorConfigRefreshRateMinutes = 120
	ConnectorConfigRefreshRateMinutes240  ConnectorConfigRefreshRateMinutes = 240
	ConnectorConfigRefreshRateMinutes480  ConnectorConfigRefreshRateMinutes = 480
	ConnectorConfigRefreshRateMinutes720  ConnectorConfigRefreshRateMinutes = 720
	ConnectorConfigRefreshRateMinutes1440 ConnectorConfigRefreshRateMinutes = 1440
)

ConnectorConfigRefreshRateMinutes values accepted by the Jamf API. The alias above is an int64, so these constants pass to any parameter or field declared as a plain int64.

func ConnectorConfigRefreshRateMinutesValues

func ConnectorConfigRefreshRateMinutesValues() []ConnectorConfigRefreshRateMinutes

ConnectorConfigRefreshRateMinutesValues returns every value the Jamf API accepts for ConnectorConfigRefreshRateMinutes, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's int64validator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type ConnectorConfigVendor

type ConnectorConfigVendor = string

ConnectorConfigVendor is the set of values accepted by ConnectorConfig.Vendor.

const (
	ConnectorConfigVendorIntune          ConnectorConfigVendor = "INTUNE"
	ConnectorConfigVendorXenmobile       ConnectorConfigVendor = "XENMOBILE"
	ConnectorConfigVendorMaas360         ConnectorConfigVendor = "MAAS360"
	ConnectorConfigVendorAirwatch        ConnectorConfigVendor = "AIRWATCH"
	ConnectorConfigVendorJamfPro         ConnectorConfigVendor = "JAMF_PRO"
	ConnectorConfigVendorJamfSchool      ConnectorConfigVendor = "JAMF_SCHOOL"
	ConnectorConfigVendorMobileironcloud ConnectorConfigVendor = "MOBILEIRONCLOUD"
	ConnectorConfigVendorMobileironcore  ConnectorConfigVendor = "MOBILEIRONCORE"
	ConnectorConfigVendorGoogle          ConnectorConfigVendor = "GOOGLE"
	ConnectorConfigVendorWizy            ConnectorConfigVendor = "WIZY"
)

ConnectorConfigVendor values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func ConnectorConfigVendorValues

func ConnectorConfigVendorValues() []ConnectorConfigVendor

ConnectorConfigVendorValues returns every value the Jamf API accepts for ConnectorConfigVendor, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type ConnectorCreateRequestBody

type ConnectorCreateRequestBody struct {
	// Allowed values: see the ConnectorCreateRequestBodyVendor constants.
	Vendor          string                                 `json:"vendor"`
	AIRWATCH        *WorkspaceOneConnectorCreateRequest    `json:"-"`
	GOOGLE          *GoogleConnectorCreateRequest          `json:"-"`
	INTUNE          *IntuneConnectorCreateRequest          `json:"-"`
	JAMFPRO         *JamfProConnectorCreateRequest         `json:"-"`
	JAMFSCHOOL      *JamfSchoolConnectorCreateRequest      `json:"-"`
	MAAS360         *Maas360ConnectorCreateRequest         `json:"-"`
	MOBILEIRONCLOUD *MobileIronCloudConnectorCreateRequest `json:"-"`
	MOBILEIRONCORE  *MobileIronCoreConnectorCreateRequest  `json:"-"`
	WIZY            *WizyConnectorCreateRequest            `json:"-"`
	XENMOBILE       *XenMobileConnectorCreateRequest       `json:"-"`
}

ConnectorCreateRequestBody The connector to create. The `vendor` field selects the contract: each vendor has its own fully typed request schema describing the fields it requires. Secret fields (credentials) are write-only — accepted on creation but never returned in any response. v1981 completed the per-vendor split this union began at v1882. Every one of the ten vendors now has its own fully typed create schema and the generic `ConnectorCreateRequest` is gone, so the mapping is 1:1 and each `Vendor` value selects exactly one contract. Set `Vendor` from `ConnectorCreateRequestBodyVendor` and populate only that vendor's fields. Only the `JAMF_PRO` variant is wire-verified. The nine others arrived as documentation in v1981 and nothing here has exercised them — the JSC sandbox tenant has no connector to replace and creating one provisions an API role on the UEM side the SDK cannot remove. Treat their required fields as upstream's claim. `additionalProperties` is open on every variant, which is upstream's choice rather than the SDK's: a field a vendor needs but the schema omits cannot be sent through the generated struct, so report the gap rather than working around it.

func (ConnectorCreateRequestBody) MarshalJSON

func (m ConnectorCreateRequestBody) MarshalJSON() ([]byte, error)

MarshalJSON emits the active variant's JSON. If the matching variant pointer is nil, emits a minimal object carrying only the discriminator.

func (*ConnectorCreateRequestBody) UnmarshalJSON

func (m *ConnectorCreateRequestBody) UnmarshalJSON(data []byte) error

UnmarshalJSON dispatches the payload to the variant matching the vendor discriminator. Unknown values leave the variant pointers nil but preserve the discriminator string.

type ConnectorCreateRequestBodyVendor

type ConnectorCreateRequestBodyVendor = string

ConnectorCreateRequestBodyVendor is the set of values accepted by ConnectorCreateRequestBody.Vendor.

const (
	ConnectorCreateRequestBodyVendorAirwatch        ConnectorCreateRequestBodyVendor = "AIRWATCH"
	ConnectorCreateRequestBodyVendorGoogle          ConnectorCreateRequestBodyVendor = "GOOGLE"
	ConnectorCreateRequestBodyVendorIntune          ConnectorCreateRequestBodyVendor = "INTUNE"
	ConnectorCreateRequestBodyVendorJamfPro         ConnectorCreateRequestBodyVendor = "JAMF_PRO"
	ConnectorCreateRequestBodyVendorJamfSchool      ConnectorCreateRequestBodyVendor = "JAMF_SCHOOL"
	ConnectorCreateRequestBodyVendorMaas360         ConnectorCreateRequestBodyVendor = "MAAS360"
	ConnectorCreateRequestBodyVendorMobileironcloud ConnectorCreateRequestBodyVendor = "MOBILEIRONCLOUD"
	ConnectorCreateRequestBodyVendorMobileironcore  ConnectorCreateRequestBodyVendor = "MOBILEIRONCORE"
	ConnectorCreateRequestBodyVendorWizy            ConnectorCreateRequestBodyVendor = "WIZY"
	ConnectorCreateRequestBodyVendorXenmobile       ConnectorCreateRequestBodyVendor = "XENMOBILE"
)

ConnectorCreateRequestBodyVendor values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func ConnectorCreateRequestBodyVendorValues

func ConnectorCreateRequestBodyVendorValues() []ConnectorCreateRequestBodyVendor

ConnectorCreateRequestBodyVendorValues returns every value the Jamf API accepts for ConnectorCreateRequestBodyVendor, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type ConnectorPage

type ConnectorPage struct {
	// The connectors for the requested page.
	Results []ConnectorConfig `json:"results"`
	// Total number of connectors across all pages.
	TotalCount int64 `json:"totalCount"`
}

ConnectorPage A page of connectors.

type CreateGroupRequest

type CreateGroupRequest struct {
	// Name of the group.
	Name string `json:"name"`
}

CreateGroupRequest Request body for creating a new device group.

type CreateResponse

type CreateResponse struct {
	// Tenant-scoped path of the created resource.
	Href string `json:"href"`
	// ID of the created resource.
	ID string `json:"id"`
}

CreateResponse Identifier and canonical URL of a newly created resource.

type CreatedResource

type CreatedResource struct {
	// Location of the created resource, as a path relative to the API base URL the request was made
	// against.
	// It is deliberately relative rather than absolute, and it does not repeat the tenant scope segment:
	// connector-service is customer-scoped downstream of the gateway and never receives the `tenantId` or
	// the external host, so it cannot construct the fully qualified tenant-scoped URL. Resolve it against
	// the same base URL — including the tenant scope prefix the publishing pipeline injects — that was
	// used for the `POST`.
	Href string `json:"href"`
	// Identifier of the created resource.
	ID string `json:"id"`
}

CreatedResource Identifier and location of a newly created resource.

type DedicatedIps

type DedicatedIps struct {
	// Whether dedicated egress IPs are provisioned for this gateway.
	Enabled bool `json:"enabled"`
	// Dedicated egress IPv4 addresses provisioned by the system. Present when `enabled: true` and
	// provisioning is complete.
	Ips *[]string `json:"ips,omitempty"`
}

DedicatedIps Dedicated egress IP configuration.

type DeviceFieldMappings

type DeviceFieldMappings struct {
	// UEM attribute the device name is read from.
	DeviceNameMapping *string `json:"deviceNameMapping,omitempty"`
	// UEM attribute the phone number is read from.
	PhoneNumberMapping *string `json:"phoneNumberMapping,omitempty"`
	// How the device email is derived. `EMAIL_ADDRESS` uses the UEM email attribute directly; any other
	// type reads from that attribute and optionally decorates it into an address.
	// Vendors that support the `CUSTOM` type carry an additional `fieldName` property naming the UEM
	// attribute to read. It is not documented as a property here because the vendors that do not support
	// `CUSTOM` do not emit it at all, and ADG-125 requires every documented field to be present in every
	// response.
	UserEmailMapping *EmailMapping `json:"userEmailMapping,omitempty"`
	// UEM attribute the user identifier is read from.
	UserIDMapping *string `json:"userIdMapping,omitempty"`
	// UEM attribute the user name is read from.
	UserNameMapping *string `json:"userNameMapping,omitempty"`
}

DeviceFieldMappings Controls which UEM attribute each JSC device field is populated from. Each value is an enum of UEM attribute names whose members are vendor-specific, so the accepted values for a given key depend on the connector's `vendor`. The Google connector accepts no mappings.

type DeviceManagementBasedAccess

type DeviceManagementBasedAccess struct {
	// Whether device management enrollment is required for access.
	Enabled bool `json:"enabled"`
	// Whether to notify users when access is blocked due to unenrolled device.
	NotificationsEnabled bool `json:"notificationsEnabled"`
}

DeviceManagementBasedAccess Device management enrollment-based access control.

type DeviceSyncAuth

type DeviceSyncAuth struct {
	// OAuth client ID. For `JAMF_PRO_OAUTH`, the client ID of an API integration on the target Jamf Pro
	// instance.
	ClientID string `json:"clientId"`
	// OAuth client secret paired with `clientId`. Write-only — never returned on a read.
	// Write-only. Servers MUST NOT return this field in responses; the SDK preserves it only so the caller
	// can supply a value on update.
	ClientSecret string `json:"clientSecret"`
	// Password paired with `username`. Write-only — never returned on a read.
	// Write-only. Servers MUST NOT return this field in responses; the SDK preserves it only so the caller
	// can supply a value on update.
	Password string `json:"password"`
	// Username, for the basic-auth strategies.
	Username string `json:"username"`
}

DeviceSyncAuth Credentials the connector authenticates to the UEM instance with, as read back off a connector. Restored from the wire (probed 2026-08-21, re-verified 2026-08-31) because the published spec omits `deviceSyncAuth` from the *response* schema; the request side is upstream's own `JamfProCredentials` as of v1882, which carries the same four members. Which of them apply depends on `authStrategy` — OAuth strategies use `clientId`/`clientSecret`, basic-auth strategies use `username`/`password`. Secrets are write-only and never returned; a read reports only `clientId`, `username` and an `empty` flag, and for an `M2M`-provisioned connector the `clientId` is the one Jamf Security Cloud minted for itself.

type DohIntegration

type DohIntegration struct {
	// Whether DoH traffic is blocked for this App.
	Blocking bool `json:"blocking"`
	// Whether to notify users when DoH traffic is blocked.
	NotificationsEnabled bool `json:"notificationsEnabled"`
}

DohIntegration DNS-over-HTTPS integration settings for the App.

type EmailMapping

type EmailMapping struct {
	// Prepended to the resolved value. Ignored when `type` is `EMAIL_ADDRESS`.
	FieldPrefix *string `json:"fieldPrefix,omitempty"`
	// Appended to the resolved value to form a full address; an `@` is inserted when the suffix does not
	// already start with one. Ignored when `type` is `EMAIL_ADDRESS`.
	FieldSuffix *string `json:"fieldSuffix,omitempty"`
	// UEM attribute the email is derived from.
	// Allowed values: see the EmailMappingType constants.
	Type string `json:"type"`
	// Apply this mapping only when the UEM email attribute is empty, rather than always.
	UseOnlyIfEmailMissing *bool `json:"useOnlyIfEmailMissing,omitempty"`
}

EmailMapping How the device email is derived. `EMAIL_ADDRESS` uses the UEM email attribute directly; any other type reads from that attribute and optionally decorates it into an address. Vendors that support the `CUSTOM` type carry an additional `fieldName` property naming the UEM attribute to read. It is not documented as a property here because the vendors that do not support `CUSTOM` do not emit it at all, and ADG-125 requires every documented field to be present in every response.

type EmailMappingType

type EmailMappingType = string

EmailMappingType is the set of values accepted by EmailMapping.Type. This set spans every UEM vendor, so `EmailMappingTypeValues()` is a superset of what any one connector accepts and is not a safe validator source. Each vendor enforces its own subset server-side and enumerates it in the `422` returned for an unknown value. A `JAMF_PRO` connector, for one, rejects `EXTERNAL_USER_ID` and `CUSTOM` — both members here — and accepts `EMAIL_ADDRESS`, `SERIAL_NUMBER`, `IMEI`, `FIRST_NAME`, `NAME`, `MDM_ID`, `DEVICE_NAME` and `LAST_NAME` (wire-verified 2026-08-28). Validate against the vendor's own set, not this one. The same caveat applies to the four sibling mapping keys on `DeviceFieldMappings`, which the spec types as plain strings for exactly this reason.

const (
	EmailMappingTypeEmailAddress   EmailMappingType = "EMAIL_ADDRESS"
	EmailMappingTypeMDMID          EmailMappingType = "MDM_ID"
	EmailMappingTypeSerialNumber   EmailMappingType = "SERIAL_NUMBER"
	EmailMappingTypeImei           EmailMappingType = "IMEI"
	EmailMappingTypeFirstName      EmailMappingType = "FIRST_NAME"
	EmailMappingTypeLastName       EmailMappingType = "LAST_NAME"
	EmailMappingTypeDeviceName     EmailMappingType = "DEVICE_NAME"
	EmailMappingTypeExternalUserID EmailMappingType = "EXTERNAL_USER_ID"
	EmailMappingTypeName           EmailMappingType = "NAME"
	EmailMappingTypeCustom         EmailMappingType = "CUSTOM"
)

EmailMappingType values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func EmailMappingTypeValues

func EmailMappingTypeValues() []EmailMappingType

EmailMappingTypeValues returns every value the Jamf API accepts for EmailMappingType, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type EnablementRequest

type EnablementRequest struct {
	// Whether the connector should be enabled for synchronization.
	Enabled bool `json:"enabled"`
}

EnablementRequest Desired enablement state for a connector.

type Gateway

type Gateway struct {
	// Public IPv4 addresses of the availability zone nodes (e.g. `18.202.42.169`). Must belong to the
	// gateway's datacenter region. Note: despite the field name, values are IPv4 addresses — not zone
	// identifier strings.
	// For **IPsec gateways**, these are the source addresses the peer firewall must allow. Valid IPs per
	// datacenter:
	// | Datacenter | Name | IP 1 | IP 2 |
	// |---|---|---|---|
	// | `af-south-1` | Africa - Cape Town | `13.244.169.182` | `13.246.106.52` |
	// | `ap-east-1` | Asia - Hong Kong | `16.163.54.105` | `16.163.15.242` |
	// | `ap-northeast-1` | Asia - Japan | `35.76.189.152` | `52.192.166.230` |
	// | `ap-south-1` | Asia - Mumbai | `3.109.252.176` | `65.1.247.99` |
	// | `ap-southeast-1` | Asia - Singapore | `18.140.158.235` | `52.77.139.71` |
	// | `ap-southeast-2` | Australia | `54.66.243.182` | `13.238.46.250` |
	// | `ca-central-1` | North America - Canada | `15.222.200.189` | `3.98.80.44` |
	// | `eu-central-1` | Europe - Germany | `3.66.107.208` | `3.121.43.105` |
	// | `eu-west-1` | Europe - Ireland | `54.220.161.57` | `18.202.42.169` |
	// | `eu-west-2` | Europe - UK | `3.9.67.90` | `18.130.213.235` |
	// | `sa-east-1` | South America - Brazil | `54.207.180.94` | `54.232.123.56` |
	// | `us-east-1` | North America - USA East | `163.123.175.1` | `163.123.175.2` |
	// | `us-west-2` | North America - USA West | `163.123.174.1` | `163.123.174.2` |
	AvailabilityZones []string `json:"availabilityZones"`
	// Operational contact for this gateway.
	Contact *GatewayContact `json:"contact,omitempty"`
	// Datacenter this gateway is deployed to (e.g. `eu-west-1`). Can be changed on PATCH — triggers
	// re-provisioning; `availabilityZones` must match the new datacenter prefix (returns `400` on
	// mismatch).
	// Allowed values: see the GatewayDatacenter constants.
	Datacenter string `json:"datacenter"`
	// Dedicated egress IP configuration.
	DedicatedIps *DedicatedIps `json:"dedicatedIps,omitempty"`
	// Whether this deployment is active.
	Enabled bool `json:"enabled"`
	// Gateway ID. Format: 4-character lowercase hexadecimal string (e.g. `a1b2`).
	ID string `json:"id"`
	// IPSec tunnel configuration returned on GET. Secrets are never included in responses.
	Ipsec *GatewayIpSec `json:"ipsec,omitempty"`
	// Human-readable name.
	Name string `json:"name"`
	// Read-only operational status of the gateway. Always present — `PENDING` on creation (or `DISABLED`
	// if `enabled: false`), then updated as infrastructure is provisioned.
	Status *GatewayStatus `json:"status,omitempty"`
	// Tenant IDs that have access to this gateway.
	TenantIds []string `json:"tenantIds"`
}

Gateway A dedicated ZTNA Gateway. Always has exactly one deployment. All deployment fields are at the top level — no nesting.

type GatewayContact

type GatewayContact struct {
	// Contact email address.
	Email string `json:"email"`
	// Contact name or team name.
	Name string `json:"name"`
}

GatewayContact Operational contact for this gateway.

type GatewayCreateRequest

type GatewayCreateRequest struct {
	// Public IPv4 addresses of the availability zone nodes to deploy into (e.g. `18.202.42.169`). Must
	// belong to the gateway's datacenter region. Must be empty when `dedicatedIps.enabled: true`. Note:
	// despite the field name, values are IPv4 addresses — not zone identifier strings.
	// For **IPsec gateways**, these are the source addresses the peer firewall must allow. Valid IPs per
	// datacenter:
	// | Datacenter | Name | IP 1 | IP 2 |
	// |---|---|---|---|
	// | `af-south-1` | Africa - Cape Town | `13.244.169.182` | `13.246.106.52` |
	// | `ap-east-1` | Asia - Hong Kong | `16.163.54.105` | `16.163.15.242` |
	// | `ap-northeast-1` | Asia - Japan | `35.76.189.152` | `52.192.166.230` |
	// | `ap-south-1` | Asia - Mumbai | `3.109.252.176` | `65.1.247.99` |
	// | `ap-southeast-1` | Asia - Singapore | `18.140.158.235` | `52.77.139.71` |
	// | `ap-southeast-2` | Australia | `54.66.243.182` | `13.238.46.250` |
	// | `ca-central-1` | North America - Canada | `15.222.200.189` | `3.98.80.44` |
	// | `eu-central-1` | Europe - Germany | `3.66.107.208` | `3.121.43.105` |
	// | `eu-west-1` | Europe - Ireland | `54.220.161.57` | `18.202.42.169` |
	// | `eu-west-2` | Europe - UK | `3.9.67.90` | `18.130.213.235` |
	// | `sa-east-1` | South America - Brazil | `54.207.180.94` | `54.232.123.56` |
	// | `us-east-1` | North America - USA East | `163.123.175.1` | `163.123.175.2` |
	// | `us-west-2` | North America - USA West | `163.123.174.1` | `163.123.174.2` |
	AvailabilityZones *[]string `json:"availabilityZones,omitempty"`
	// Operational contact for this gateway.
	Contact GatewayContact `json:"contact"`
	// Target datacenter identifier (e.g. `eu-west-1`).
	// Allowed values: see the GatewayCreateRequestDatacenter constants.
	Datacenter string `json:"datacenter"`
	// Dedicated egress IP configuration.
	DedicatedIps *DedicatedIps `json:"dedicatedIps,omitempty"`
	// Whether the deployment should be active on creation.
	Enabled *bool `json:"enabled,omitempty"`
	// IPSec tunnel configuration for POST requests. All fields required. `left.secret` sets the pre-shared
	// key — it is automatically applied to both tunnel endpoints.
	Ipsec *GatewayIpSecRequest `json:"ipsec,omitempty"`
	// Human-readable name.
	Name string `json:"name"`
	// Tenant IDs to grant access. Validated against the caller's organization — **403** if mismatched.
	TenantIds []string `json:"tenantIds"`
}

GatewayCreateRequest Flat request body for creating a dedicated Gateway.

type GatewayCreateRequestDatacenter

type GatewayCreateRequestDatacenter = string

GatewayCreateRequestDatacenter is the set of values accepted by GatewayCreateRequest.Datacenter.

const (
	GatewayCreateRequestDatacenterAfSouth1     GatewayCreateRequestDatacenter = "af-south-1"
	GatewayCreateRequestDatacenterApEast1      GatewayCreateRequestDatacenter = "ap-east-1"
	GatewayCreateRequestDatacenterApNortheast1 GatewayCreateRequestDatacenter = "ap-northeast-1"
	GatewayCreateRequestDatacenterApSouth1     GatewayCreateRequestDatacenter = "ap-south-1"
	GatewayCreateRequestDatacenterApSoutheast1 GatewayCreateRequestDatacenter = "ap-southeast-1"
	GatewayCreateRequestDatacenterApSoutheast2 GatewayCreateRequestDatacenter = "ap-southeast-2"
	GatewayCreateRequestDatacenterCaCentral1   GatewayCreateRequestDatacenter = "ca-central-1"
	GatewayCreateRequestDatacenterEuCentral1   GatewayCreateRequestDatacenter = "eu-central-1"
	GatewayCreateRequestDatacenterEuWest1      GatewayCreateRequestDatacenter = "eu-west-1"
	GatewayCreateRequestDatacenterEuWest2      GatewayCreateRequestDatacenter = "eu-west-2"
	GatewayCreateRequestDatacenterSaEast1      GatewayCreateRequestDatacenter = "sa-east-1"
	GatewayCreateRequestDatacenterUsEast1      GatewayCreateRequestDatacenter = "us-east-1"
	GatewayCreateRequestDatacenterUsWest2      GatewayCreateRequestDatacenter = "us-west-2"
)

GatewayCreateRequestDatacenter values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func GatewayCreateRequestDatacenterValues

func GatewayCreateRequestDatacenterValues() []GatewayCreateRequestDatacenter

GatewayCreateRequestDatacenterValues returns every value the Jamf API accepts for GatewayCreateRequestDatacenter, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type GatewayDatacenter

type GatewayDatacenter = string

GatewayDatacenter is the set of values accepted by Gateway.Datacenter.

const (
	GatewayDatacenterAfSouth1     GatewayDatacenter = "af-south-1"
	GatewayDatacenterApEast1      GatewayDatacenter = "ap-east-1"
	GatewayDatacenterApNortheast1 GatewayDatacenter = "ap-northeast-1"
	GatewayDatacenterApSouth1     GatewayDatacenter = "ap-south-1"
	GatewayDatacenterApSoutheast1 GatewayDatacenter = "ap-southeast-1"
	GatewayDatacenterApSoutheast2 GatewayDatacenter = "ap-southeast-2"
	GatewayDatacenterCaCentral1   GatewayDatacenter = "ca-central-1"
	GatewayDatacenterEuCentral1   GatewayDatacenter = "eu-central-1"
	GatewayDatacenterEuWest1      GatewayDatacenter = "eu-west-1"
	GatewayDatacenterEuWest2      GatewayDatacenter = "eu-west-2"
	GatewayDatacenterSaEast1      GatewayDatacenter = "sa-east-1"
	GatewayDatacenterUsEast1      GatewayDatacenter = "us-east-1"
	GatewayDatacenterUsWest2      GatewayDatacenter = "us-west-2"
)

GatewayDatacenter values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func GatewayDatacenterValues

func GatewayDatacenterValues() []GatewayDatacenter

GatewayDatacenterValues returns every value the Jamf API accepts for GatewayDatacenter, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type GatewayIpSec

type GatewayIpSec struct {
	// Cipher suite configuration for an IKE or ESP phase.
	Esp *CipherSuiteConfig `json:"esp,omitempty"`
	// Cipher suite configuration for an IKE or ESP phase.
	Ike *CipherSuiteConfig `json:"ike,omitempty"`
	// IKE version.
	// Allowed values: see the GatewayIpSecKeyExchange constants.
	KeyExchange string `json:"keyExchange"`
	// IPSec Jamf-side endpoint returned on GET. Secrets are never included.
	Left *ConnectionConfigLeftResponse `json:"left,omitempty"`
	// IPSec remote-peer endpoint returned on GET. Secrets are never included.
	Right *ConnectionConfigRightResponse `json:"right,omitempty"`
}

GatewayIpSec IPSec tunnel configuration returned on GET. Secrets are never included in responses.

type GatewayIpSecKeyExchange

type GatewayIpSecKeyExchange = string

GatewayIpSecKeyExchange is the set of values accepted by GatewayIpSec.KeyExchange.

const (
	GatewayIpSecKeyExchangeIkev1 GatewayIpSecKeyExchange = "ikev1"
	GatewayIpSecKeyExchangeIkev2 GatewayIpSecKeyExchange = "ikev2"
)

GatewayIpSecKeyExchange values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func GatewayIpSecKeyExchangeValues

func GatewayIpSecKeyExchangeValues() []GatewayIpSecKeyExchange

GatewayIpSecKeyExchangeValues returns every value the Jamf API accepts for GatewayIpSecKeyExchange, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type GatewayIpSecPatchRequest

type GatewayIpSecPatchRequest struct {
	// Cipher suite configuration for an IKE or ESP phase.
	Esp *CipherSuiteConfig `json:"esp,omitempty"`
	// Cipher suite configuration for an IKE or ESP phase.
	Ike *CipherSuiteConfig `json:"ike,omitempty"`
	// IKE version.
	// Allowed values: see the GatewayIpSecPatchRequestKeyExchange constants.
	KeyExchange *string `json:"keyExchange,omitempty"`
	// IPSec connection endpoint for PATCH `left`. All fields optional — supply only the fields to
	// update. `secret` is write-only; omit to preserve the existing PSK; sending `null` returns `400
	// IPSEC_SECRET_CLEAR_NOT_SUPPORTED`.
	Left *ConnectionConfigPatchLeftRequest `json:"left,omitempty"`
	// IPSec connection endpoint for PATCH `right` (remote peer). The secret is always derived from
	// `left.secret` — callers never supply it here.
	Right *ConnectionConfigPatchRightRequest `json:"right,omitempty"`
}

GatewayIpSecPatchRequest Partial IPSec configuration for PATCH. All fields optional — fields are deep-merged. Supply only `left.secret` to rotate the pre-shared key, or the full block to replace cipher suites and endpoint addresses simultaneously. `right.secret` is derived automatically from `left.secret` — callers never set it directly.

type GatewayIpSecPatchRequestKeyExchange

type GatewayIpSecPatchRequestKeyExchange = string

GatewayIpSecPatchRequestKeyExchange is the set of values accepted by GatewayIpSecPatchRequest.KeyExchange.

const (
	GatewayIpSecPatchRequestKeyExchangeIkev1 GatewayIpSecPatchRequestKeyExchange = "ikev1"
	GatewayIpSecPatchRequestKeyExchangeIkev2 GatewayIpSecPatchRequestKeyExchange = "ikev2"
)

GatewayIpSecPatchRequestKeyExchange values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func GatewayIpSecPatchRequestKeyExchangeValues

func GatewayIpSecPatchRequestKeyExchangeValues() []GatewayIpSecPatchRequestKeyExchange

GatewayIpSecPatchRequestKeyExchangeValues returns every value the Jamf API accepts for GatewayIpSecPatchRequestKeyExchange, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type GatewayIpSecRequest

type GatewayIpSecRequest struct {
	// Cipher suite configuration for an IKE or ESP phase.
	Esp CipherSuiteConfig `json:"esp"`
	// Cipher suite configuration for an IKE or ESP phase.
	Ike CipherSuiteConfig `json:"ike"`
	// IKE version.
	// Allowed values: see the GatewayIpSecRequestKeyExchange constants.
	KeyExchange string `json:"keyExchange"`
	// IPSec connection endpoint for write requests. Includes the `secret` field. `secret` is write-only
	// — it is never returned in GET responses.
	Left ConnectionConfigLeftRequest `json:"left"`
	// IPSec connection endpoint for the `right` (remote peer) side. The secret is derived automatically
	// from `left.secret` — callers never supply it here. `vendor` is **required** — use the peer's VPN
	// vendor identifier (e.g. `cisco`, `strongSwan`, `juniper`).
	Right ConnectionConfigRightRequest `json:"right"`
}

GatewayIpSecRequest IPSec tunnel configuration for POST requests. All fields required. `left.secret` sets the pre-shared key — it is automatically applied to both tunnel endpoints.

type GatewayIpSecRequestKeyExchange

type GatewayIpSecRequestKeyExchange = string

GatewayIpSecRequestKeyExchange is the set of values accepted by GatewayIpSecRequest.KeyExchange.

const (
	GatewayIpSecRequestKeyExchangeIkev1 GatewayIpSecRequestKeyExchange = "ikev1"
	GatewayIpSecRequestKeyExchangeIkev2 GatewayIpSecRequestKeyExchange = "ikev2"
)

GatewayIpSecRequestKeyExchange values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func GatewayIpSecRequestKeyExchangeValues

func GatewayIpSecRequestKeyExchangeValues() []GatewayIpSecRequestKeyExchange

GatewayIpSecRequestKeyExchangeValues returns every value the Jamf API accepts for GatewayIpSecRequestKeyExchange, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type GatewayListResponse

type GatewayListResponse struct {
	Results []Gateway `json:"results"`
	// Total number of items across all pages.
	TotalCount int `json:"totalCount"`
}

GatewayListResponse List of Gateways with a total count.

type GatewayPatchRequest

type GatewayPatchRequest struct {
	// Replaces the availability zone node list. Accepts public IPv4 addresses (e.g. `18.202.42.169`).
	// Zones must belong to the (new or existing) datacenter.
	// For **IPsec gateways**, these are the source addresses the peer firewall must allow. Valid IPs per
	// datacenter:
	// | Datacenter | Name | IP 1 | IP 2 |
	// |---|---|---|---|
	// | `af-south-1` | Africa - Cape Town | `13.244.169.182` | `13.246.106.52` |
	// | `ap-east-1` | Asia - Hong Kong | `16.163.54.105` | `16.163.15.242` |
	// | `ap-northeast-1` | Asia - Japan | `35.76.189.152` | `52.192.166.230` |
	// | `ap-south-1` | Asia - Mumbai | `3.109.252.176` | `65.1.247.99` |
	// | `ap-southeast-1` | Asia - Singapore | `18.140.158.235` | `52.77.139.71` |
	// | `ap-southeast-2` | Australia | `54.66.243.182` | `13.238.46.250` |
	// | `ca-central-1` | North America - Canada | `15.222.200.189` | `3.98.80.44` |
	// | `eu-central-1` | Europe - Germany | `3.66.107.208` | `3.121.43.105` |
	// | `eu-west-1` | Europe - Ireland | `54.220.161.57` | `18.202.42.169` |
	// | `eu-west-2` | Europe - UK | `3.9.67.90` | `18.130.213.235` |
	// | `sa-east-1` | South America - Brazil | `54.207.180.94` | `54.232.123.56` |
	// | `us-east-1` | North America - USA East | `163.123.175.1` | `163.123.175.2` |
	// | `us-west-2` | North America - USA West | `163.123.174.1` | `163.123.174.2` |
	AvailabilityZones *[]string `json:"availabilityZones,omitempty"`
	// Operational contact for this gateway.
	Contact *GatewayContact `json:"contact,omitempty"`
	// New datacenter for this deployment (e.g. `eu-central-1`). When changed, `availabilityZones` must
	// match the new datacenter prefix — returns `400` on mismatch. **Destructive:** triggers
	// re-provisioning, connectivity outage, and immediate `status.state` reset to `PENDING`.
	// `dedicatedIps.ips` remain stale until VSC completes provisioning in the new datacenter.
	// Allowed values: see the GatewayPatchRequestDatacenter constants.
	Datacenter *string `json:"datacenter,omitempty"`
	// Whether the deployment should be active.
	Enabled *bool `json:"enabled,omitempty"`
	// Partial IPSec configuration for PATCH. All fields optional — fields are deep-merged. Supply only
	// `left.secret` to rotate the pre-shared key, or the full block to replace cipher suites and endpoint
	// addresses simultaneously. `right.secret` is derived automatically from `left.secret` — callers
	// never set it directly.
	Ipsec *GatewayIpSecPatchRequest `json:"ipsec,omitempty"`
	// New name for the gateway.
	Name *string `json:"name,omitempty"`
	// Replaces the full tenantIds list. Validated against the caller's organization — **403** if
	// mismatched. Setting `tenantIds: []` (empty array) returns `400` — `minItems: 1` enforced by
	// schema.
	TenantIds *[]string `json:"tenantIds,omitempty"`
}

GatewayPatchRequest Flat merge-patch body (`application/merge-patch+json`). All fields optional. When `datacenter` is omitted, the existing value is preserved. When `datacenter` changes, `availabilityZones` must match the new datacenter prefix (e.g. `eu-central-1a` for `eu-central-1`) — returns `400` on mismatch.

type GatewayPatchRequestDatacenter

type GatewayPatchRequestDatacenter = string

GatewayPatchRequestDatacenter is the set of values accepted by GatewayPatchRequest.Datacenter.

const (
	GatewayPatchRequestDatacenterAfSouth1     GatewayPatchRequestDatacenter = "af-south-1"
	GatewayPatchRequestDatacenterApEast1      GatewayPatchRequestDatacenter = "ap-east-1"
	GatewayPatchRequestDatacenterApNortheast1 GatewayPatchRequestDatacenter = "ap-northeast-1"
	GatewayPatchRequestDatacenterApSouth1     GatewayPatchRequestDatacenter = "ap-south-1"
	GatewayPatchRequestDatacenterApSoutheast1 GatewayPatchRequestDatacenter = "ap-southeast-1"
	GatewayPatchRequestDatacenterApSoutheast2 GatewayPatchRequestDatacenter = "ap-southeast-2"
	GatewayPatchRequestDatacenterCaCentral1   GatewayPatchRequestDatacenter = "ca-central-1"
	GatewayPatchRequestDatacenterEuCentral1   GatewayPatchRequestDatacenter = "eu-central-1"
	GatewayPatchRequestDatacenterEuWest1      GatewayPatchRequestDatacenter = "eu-west-1"
	GatewayPatchRequestDatacenterEuWest2      GatewayPatchRequestDatacenter = "eu-west-2"
	GatewayPatchRequestDatacenterSaEast1      GatewayPatchRequestDatacenter = "sa-east-1"
	GatewayPatchRequestDatacenterUsEast1      GatewayPatchRequestDatacenter = "us-east-1"
	GatewayPatchRequestDatacenterUsWest2      GatewayPatchRequestDatacenter = "us-west-2"
)

GatewayPatchRequestDatacenter values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func GatewayPatchRequestDatacenterValues

func GatewayPatchRequestDatacenterValues() []GatewayPatchRequestDatacenter

GatewayPatchRequestDatacenterValues returns every value the Jamf API accepts for GatewayPatchRequestDatacenter, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type GatewayStatus

type GatewayStatus struct {
	// Composite status derived from infrastructure and tunnel health. `PENDING` — gateway is being
	// provisioned. `UP` — gateway is fully operational. `DOWN` — gateway is unreachable or degraded.
	// `DISABLED` — gateway has `enabled: false`.
	// Allowed values: see the GatewayStatusState constants.
	State string `json:"state"`
	// IPSec tunnel health. Present only when the gateway has an IPSec configuration. `null` for non-IPSec
	// gateways or before VSC reports the first tunnel status.
	// Allowed values: see the GatewayStatusTunnelState constants.
	TunnelState *string `json:"tunnelState,omitempty"`
	// Timestamp of the last status update.
	UpdatedAt time.Time `json:"updatedAt"`
}

GatewayStatus Read-only operational status of the gateway. Always present — `PENDING` on creation (or `DISABLED` if `enabled: false`), then updated as infrastructure is provisioned.

type GatewayStatusState

type GatewayStatusState = string

GatewayStatusState is the set of values accepted by GatewayStatus.State.

const (
	GatewayStatusStateUp       GatewayStatusState = "UP"
	GatewayStatusStateDown     GatewayStatusState = "DOWN"
	GatewayStatusStatePending  GatewayStatusState = "PENDING"
	GatewayStatusStateDisabled GatewayStatusState = "DISABLED"
)

GatewayStatusState values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func GatewayStatusStateValues

func GatewayStatusStateValues() []GatewayStatusState

GatewayStatusStateValues returns every value the Jamf API accepts for GatewayStatusState, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type GatewayStatusTunnelState

type GatewayStatusTunnelState = string

GatewayStatusTunnelState is the set of values accepted by GatewayStatus.TunnelState.

const (
	GatewayStatusTunnelStateUp   GatewayStatusTunnelState = "UP"
	GatewayStatusTunnelStateDown GatewayStatusTunnelState = "DOWN"
)

GatewayStatusTunnelState values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func GatewayStatusTunnelStateValues

func GatewayStatusTunnelStateValues() []GatewayStatusTunnelState

GatewayStatusTunnelStateValues returns every value the Jamf API accepts for GatewayStatusTunnelState, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type GoogleApiSettings

type GoogleApiSettings struct {
	// OAuth client id.
	ClientID string `json:"clientId"`
	// OAuth client secret.
	// Write-only. Servers MUST NOT return this field in responses; the SDK preserves it only so the caller
	// can supply a value on update.
	ClientSecret *string `json:"clientSecret,omitempty"`
}

GoogleApiSettings OAuth client credentials for the Google API.

type GoogleConnectorCreateRequest

type GoogleConnectorCreateRequest struct {
	// OAuth client credentials for the Google API.
	ApiSettings *GoogleApiSettings `json:"apiSettings,omitempty"`
	// Override for the Google authentication URL.
	AuthURL *string `json:"authUrl,omitempty"`
	// ISO country code for the UEM instance, when applicable.
	IsoCountry *string `json:"isoCountry,omitempty"`
	// Google API URL.
	URL string `json:"url"`
	// UEM vendor discriminator.
	// Allowed values: see the GoogleConnectorCreateRequestVendor constants.
	Vendor string `json:"vendor"`
}

GoogleConnectorCreateRequest Connector creation request for Google (Chrome / Android Enterprise). The OAuth client credentials (`apiSettings`) and the `authUrl` override are optional; JSC falls back to Google defaults when they are omitted.

type GoogleConnectorCreateRequestVendor

type GoogleConnectorCreateRequestVendor = string

GoogleConnectorCreateRequestVendor is the set of values accepted by GoogleConnectorCreateRequest.Vendor.

const (
	GoogleConnectorCreateRequestVendorGoogle GoogleConnectorCreateRequestVendor = "GOOGLE"
)

GoogleConnectorCreateRequestVendor values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func GoogleConnectorCreateRequestVendorValues

func GoogleConnectorCreateRequestVendorValues() []GoogleConnectorCreateRequestVendor

GoogleConnectorCreateRequestVendorValues returns every value the Jamf API accepts for GoogleConnectorCreateRequestVendor, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type Group

type Group struct {
	// Unique group identifier.
	ID string `json:"id"`
	// Display name of the group.
	Name string `json:"name"`
}

Group Represents a device group in Security Cloud.

type GroupListItem

type GroupListItem struct {
	// Unique group identifier. Omitted for the implicit "Default Group" entry, which is not a stored
	// group.
	ID string `json:"id"`
	// Display name of the group.
	Name string `json:"name"`
}

GroupListItem A device group as returned by the list endpoints. Identical to Group, except that the implicit "Default Group" entry has no identifier and so omits the id field.

type GroupListResponseV2

type GroupListResponseV2 struct {
	// Device groups belonging to the customer. Always contains at least the implicit "Default Group"
	// entry.
	Groups []GroupListItem `json:"groups"`
}

GroupListResponseV2 List of device groups for the authenticated customer.

type GroupMapping

type GroupMapping struct {
	// Group ID in the UEM platform. Group names are not accepted.
	// For Jamf Pro the device-type prefix is **required** here — `computer_<id>` or `mobile_<id>` —
	// unlike `ActivationProfileDeployRequest.uemGroups`, where a bare numeric ID is also accepted. A value
	// without the prefix is rejected.
	EmmGroupID string `json:"emmGroupId"`
	// JSC group identifier devices in the UEM group are assigned to.
	WanderaGroupID string `json:"wanderaGroupId"`
}

GroupMapping A single UEM-group-to-JSC-group assignment. Both property names retain legacy internal product names (`emm` for UEM, `wandera` for JSC). They are the names the service serializes and accepts today, so they are documented as-is; renaming them would break existing callers.

type GroupOverrides

type GroupOverrides struct {
	RoutingOverrides *[]RoutingOverride `json:"routingOverrides,omitempty"`
}

GroupOverrides Per-group routing overrides that take precedence over the App's default routing. Each override's `groupIds` must be a subset of `assignments.inclusions.groups` (or `allUsers: true`); references to unassigned groups return `400`.

type GroupSettings

type GroupSettings struct {
	// JSC group that devices are assigned to when no explicit mapping matches.
	DefaultGroupID *string `json:"defaultGroupId,omitempty"`
	// Whether group mapping is applied during sync.
	GroupMappingEnabled *bool `json:"groupMappingEnabled,omitempty"`
	// Explicit UEM-group-to-JSC-group assignments. Replaces the existing set on update; send an empty
	// array to clear all mappings.
	GroupMappings *[]GroupMapping `json:"groupMappings,omitempty"`
}

GroupSettings Group mapping configuration. Maps UEM groups to JSC groups.

type GroupedGateway

type GroupedGateway struct {
	// When the Grouped Gateway was created.
	CreatedAt time.Time `json:"createdAt"`
	// IDs of member Gateways (minimum 2). Discover via `GET /gateways`. All members must be dedicated
	// gateways (not from `GET /shared-gateways`), must have the same tunnel type (all IPSec or all
	// non-IPSec), and the same `dedicatedIps.enabled` value — `422` on violation.
	GatewayIds []string `json:"gatewayIds"`
	// Grouped Gateway ID. Format: UUID (e.g. `3fa85f64-5717-4562-b3fc-2c963f66afa6`).
	ID string `json:"id"`
	// Human-readable name.
	Name string `json:"name"`
	// Recovery delay in seconds for the `ACTIVE_STANDBY` strategy — how long to wait before failing back
	// to the primary after it recovers. New and updated grouped gateways use one of the supported
	// durations (`300`, `1800`, `3600`, `10800`, `28800`); grouped gateways created earlier may return a
	// legacy value. Ignored for `RANDOM` and `NEAREST` strategies.
	RecoveryDelayInSec int `json:"recoveryDelayInSec"`
	// `ACTIVE_STANDBY` — traffic goes to the primary gateway; failover to secondary on failure. `RANDOM`
	// — traffic is distributed randomly across gateways. `NEAREST` — traffic routes to the
	// geographically closest gateway.
	RoutingStrategy RoutingStrategy `json:"routingStrategy"`
	// Tenant IDs with access to this grouped gateway.
	TenantIds []string `json:"tenantIds"`
	// Last update to the Grouped Gateway.
	UpdatedAt time.Time `json:"updatedAt"`
}

GroupedGateway A logical group of two or more Gateways with a shared routing strategy.

type GroupedGatewayCreateRequest

type GroupedGatewayCreateRequest struct {
	// IDs of member Gateways (minimum 2).
	GatewayIds []string `json:"gatewayIds"`
	// Human-readable name.
	Name string `json:"name"`
	// Required gateway stability before failover, in seconds, for the `ACTIVE_STANDBY` strategy. Must be
	// one of the listed durations (mirrors the Jamf console). Required on create even for
	// `RANDOM`/`NEAREST`, where it is ignored.
	// Allowed values: see the GroupedGatewayCreateRequestRecoveryDelayInSec constants.
	RecoveryDelayInSec int `json:"recoveryDelayInSec"`
	// `ACTIVE_STANDBY` — traffic goes to the primary gateway; failover to secondary on failure. `RANDOM`
	// — traffic is distributed randomly across gateways. `NEAREST` — traffic routes to the
	// geographically closest gateway.
	RoutingStrategy RoutingStrategy `json:"routingStrategy"`
	// Tenant IDs to grant access. Validated against the caller's organization — **403** if mismatched.
	TenantIds []string `json:"tenantIds"`
}

GroupedGatewayCreateRequest Request body for creating a Grouped Gateway.

type GroupedGatewayCreateRequestRecoveryDelayInSec

type GroupedGatewayCreateRequestRecoveryDelayInSec = int

GroupedGatewayCreateRequestRecoveryDelayInSec is the set of values accepted by GroupedGatewayCreateRequest.RecoveryDelayInSec.

const (
	GroupedGatewayCreateRequestRecoveryDelayInSec300   GroupedGatewayCreateRequestRecoveryDelayInSec = 300
	GroupedGatewayCreateRequestRecoveryDelayInSec1800  GroupedGatewayCreateRequestRecoveryDelayInSec = 1800
	GroupedGatewayCreateRequestRecoveryDelayInSec3600  GroupedGatewayCreateRequestRecoveryDelayInSec = 3600
	GroupedGatewayCreateRequestRecoveryDelayInSec10800 GroupedGatewayCreateRequestRecoveryDelayInSec = 10800
	GroupedGatewayCreateRequestRecoveryDelayInSec28800 GroupedGatewayCreateRequestRecoveryDelayInSec = 28800
)

GroupedGatewayCreateRequestRecoveryDelayInSec values accepted by the Jamf API. The alias above is an int, so these constants pass to any parameter or field declared as a plain int.

func GroupedGatewayCreateRequestRecoveryDelayInSecValues

func GroupedGatewayCreateRequestRecoveryDelayInSecValues() []GroupedGatewayCreateRequestRecoveryDelayInSec

GroupedGatewayCreateRequestRecoveryDelayInSecValues returns every value the Jamf API accepts for GroupedGatewayCreateRequestRecoveryDelayInSec, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's int64validator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type GroupedGatewayListResponse

type GroupedGatewayListResponse struct {
	Results []GroupedGateway `json:"results"`
	// Total number of items across all pages.
	TotalCount int `json:"totalCount"`
}

GroupedGatewayListResponse List of Grouped Gateways with a total count.

type GroupedGatewayPatchRequest

type GroupedGatewayPatchRequest struct {
	// Replaces the full member gateway list (minimum 2).
	GatewayIds *[]string `json:"gatewayIds,omitempty"`
	// New name for the grouped gateway.
	Name *string `json:"name,omitempty"`
	// Recovery delay in seconds for the `ACTIVE_STANDBY` strategy. If provided, must be one of the listed
	// durations. Omit to leave unchanged. Grouped gateways created before this constraint may hold a
	// legacy value; `recoveryDelayInSec` is unaffected on PATCH operations that omit it.
	// Allowed values: see the GroupedGatewayPatchRequestRecoveryDelayInSec constants.
	RecoveryDelayInSec *int `json:"recoveryDelayInSec,omitempty"`
	// `ACTIVE_STANDBY` — traffic goes to the primary gateway; failover to secondary on failure. `RANDOM`
	// — traffic is distributed randomly across gateways. `NEAREST` — traffic routes to the
	// geographically closest gateway.
	RoutingStrategy *RoutingStrategy `json:"routingStrategy,omitempty"`
	// Replaces the full tenantIds list. Validated against the caller's organization — **403** if
	// mismatched. Setting `tenantIds: []` (empty array) returns `400` — `minItems: 1` enforced by
	// schema.
	TenantIds *[]string `json:"tenantIds,omitempty"`
}

GroupedGatewayPatchRequest Merge-patch body (`application/merge-patch+json`) for partial Grouped Gateway update. All fields optional — include only what you want to change.

type GroupedGatewayPatchRequestRecoveryDelayInSec

type GroupedGatewayPatchRequestRecoveryDelayInSec = int

GroupedGatewayPatchRequestRecoveryDelayInSec is the set of values accepted by GroupedGatewayPatchRequest.RecoveryDelayInSec.

const (
	GroupedGatewayPatchRequestRecoveryDelayInSec300   GroupedGatewayPatchRequestRecoveryDelayInSec = 300
	GroupedGatewayPatchRequestRecoveryDelayInSec1800  GroupedGatewayPatchRequestRecoveryDelayInSec = 1800
	GroupedGatewayPatchRequestRecoveryDelayInSec3600  GroupedGatewayPatchRequestRecoveryDelayInSec = 3600
	GroupedGatewayPatchRequestRecoveryDelayInSec10800 GroupedGatewayPatchRequestRecoveryDelayInSec = 10800
	GroupedGatewayPatchRequestRecoveryDelayInSec28800 GroupedGatewayPatchRequestRecoveryDelayInSec = 28800
)

GroupedGatewayPatchRequestRecoveryDelayInSec values accepted by the Jamf API. The alias above is an int, so these constants pass to any parameter or field declared as a plain int.

func GroupedGatewayPatchRequestRecoveryDelayInSecValues

func GroupedGatewayPatchRequestRecoveryDelayInSecValues() []GroupedGatewayPatchRequestRecoveryDelayInSec

GroupedGatewayPatchRequestRecoveryDelayInSecValues returns every value the Jamf API accepts for GroupedGatewayPatchRequestRecoveryDelayInSec, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's int64validator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type IntuneApiCredentials

type IntuneApiCredentials struct {
	// OAuth client (application) id.
	ClientID string `json:"clientId"`
	// OAuth client secret.
	// Write-only. Servers MUST NOT return this field in responses; the SDK preserves it only so the caller
	// can supply a value on update.
	ClientSecret *string `json:"clientSecret,omitempty"`
}

IntuneApiCredentials OAuth client credentials for a single Intune API.

type IntuneConnectorCreateRequest

type IntuneConnectorCreateRequest struct {
	// Override for the Microsoft Graph authentication URL.
	GraphAuthURL *string `json:"graphAuthUrl,omitempty"`
	// Override for the Microsoft Graph API URL.
	GraphURL *string `json:"graphUrl,omitempty"`
	// ISO country code for the UEM instance, when applicable.
	IsoCountry *string `json:"isoCountry,omitempty"`
	// OAuth client credentials for a single Intune API.
	Lcm *IntuneApiCredentials `json:"lcm,omitempty"`
	// OAuth client credentials for a single Intune API.
	Mtd *IntuneApiCredentials `json:"mtd,omitempty"`
	// Override for the Mobile Threat Defense API URL.
	MtdURL *string `json:"mtdUrl,omitempty"`
	// Override for the authentication URL of the non-Graph Intune APIs.
	OtherApisAuthURL *string `json:"otherApisAuthUrl,omitempty"`
	// OAuth client credentials for a single Intune API.
	Tag *IntuneApiCredentials `json:"tag,omitempty"`
	// Intune (Microsoft Graph) server URL.
	URL string `json:"url"`
	// UEM vendor discriminator.
	// Allowed values: see the IntuneConnectorCreateRequestVendor constants.
	Vendor string `json:"vendor"`
}

IntuneConnectorCreateRequest Connector creation request for Microsoft Intune. JSC talks to three Intune APIs — lifecycle management (`lcm`), Mobile Threat Defense (`mtd`), and device tagging (`tag`) — each authenticated with its own OAuth client credentials. The endpoint-URL overrides are optional and default to Microsoft's public endpoints when omitted.

type IntuneConnectorCreateRequestVendor

type IntuneConnectorCreateRequestVendor = string

IntuneConnectorCreateRequestVendor is the set of values accepted by IntuneConnectorCreateRequest.Vendor.

const (
	IntuneConnectorCreateRequestVendorIntune IntuneConnectorCreateRequestVendor = "INTUNE"
)

IntuneConnectorCreateRequestVendor values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func IntuneConnectorCreateRequestVendorValues

func IntuneConnectorCreateRequestVendorValues() []IntuneConnectorCreateRequestVendor

IntuneConnectorCreateRequestVendorValues returns every value the Jamf API accepts for IntuneConnectorCreateRequestVendor, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type JamfProConnectorCreateRequest

type JamfProConnectorCreateRequest struct {
	// Authentication strategy used to connect to Jamf Pro. See the schema description for the fields each
	// strategy requires.
	// Allowed values: see the JamfProConnectorCreateRequestAuthStrategy constants.
	AuthStrategy string `json:"authStrategy"`
	// Jamf Pro connection credentials. Provide the OAuth pair (`clientId` + `clientSecret`) when
	// `authStrategy` is `JAMF_PRO_OAUTH`, or the basic pair (`username` + `password`) when `authStrategy`
	// is `BASIC`. Omit entirely for `M2M`.
	DeviceSyncAuth *JamfProCredentials `json:"deviceSyncAuth,omitempty"`
	// ISO country code for the UEM instance, when applicable.
	IsoCountry *string `json:"isoCountry,omitempty"`
	// Jamf Pro tenant identifier. Required when `authStrategy` is `M2M`; must be omitted for the other
	// strategies.
	// Write-only. Servers MUST NOT return this field in responses; the SDK preserves it only so the caller
	// can supply a value on update.
	TenantID *string `json:"tenantId,omitempty"`
	// Jamf Pro server URL.
	URL string `json:"url"`
	// UEM vendor discriminator.
	// Allowed values: see the JamfProConnectorCreateRequestVendor constants.
	Vendor string `json:"vendor"`
}

JamfProConnectorCreateRequest Connector creation request for Jamf Pro. The `authStrategy` field selects how JSC authenticates to Jamf Pro and determines which further fields are required: - `JAMF_PRO_OAUTH` — provide `deviceSyncAuth.clientId` and `deviceSyncAuth.clientSecret` (Jamf Pro API-role OAuth client credentials). - `BASIC` — provide `deviceSyncAuth.username` and `deviceSyncAuth.password`. - `M2M` — provide `tenantId`; `deviceSyncAuth` must be omitted (JSC authenticates through the shared machine-to-machine trust rather than per-connector credentials). The credential fields (`deviceSyncAuth.password`, `deviceSyncAuth.clientSecret`) are write-only. `tenantId` is likewise write-only: it is accepted on creation but not returned in responses. Write-only fields are never echoed back in any response.

type JamfProConnectorCreateRequestAuthStrategy

type JamfProConnectorCreateRequestAuthStrategy = string

JamfProConnectorCreateRequestAuthStrategy is the set of values accepted by JamfProConnectorCreateRequest.AuthStrategy.

const (
	JamfProConnectorCreateRequestAuthStrategyJamfProOauth JamfProConnectorCreateRequestAuthStrategy = "JAMF_PRO_OAUTH"
	JamfProConnectorCreateRequestAuthStrategyBasic        JamfProConnectorCreateRequestAuthStrategy = "BASIC"
	JamfProConnectorCreateRequestAuthStrategyM2m          JamfProConnectorCreateRequestAuthStrategy = "M2M"
)

JamfProConnectorCreateRequestAuthStrategy values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func JamfProConnectorCreateRequestAuthStrategyValues

func JamfProConnectorCreateRequestAuthStrategyValues() []JamfProConnectorCreateRequestAuthStrategy

JamfProConnectorCreateRequestAuthStrategyValues returns every value the Jamf API accepts for JamfProConnectorCreateRequestAuthStrategy, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type JamfProConnectorCreateRequestVendor

type JamfProConnectorCreateRequestVendor = string

JamfProConnectorCreateRequestVendor is the set of values accepted by JamfProConnectorCreateRequest.Vendor.

const (
	JamfProConnectorCreateRequestVendorJamfPro JamfProConnectorCreateRequestVendor = "JAMF_PRO"
)

JamfProConnectorCreateRequestVendor values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func JamfProConnectorCreateRequestVendorValues

func JamfProConnectorCreateRequestVendorValues() []JamfProConnectorCreateRequestVendor

JamfProConnectorCreateRequestVendorValues returns every value the Jamf API accepts for JamfProConnectorCreateRequestVendor, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type JamfProCredentials

type JamfProCredentials struct {
	// Jamf Pro API-role OAuth client id (JAMF_PRO_OAUTH strategy).
	ClientID *string `json:"clientId,omitempty"`
	// Jamf Pro API-role OAuth client secret (JAMF_PRO_OAUTH strategy).
	// Write-only. Servers MUST NOT return this field in responses; the SDK preserves it only so the caller
	// can supply a value on update.
	ClientSecret *string `json:"clientSecret,omitempty"`
	// Jamf Pro password (BASIC strategy).
	// Write-only. Servers MUST NOT return this field in responses; the SDK preserves it only so the caller
	// can supply a value on update.
	Password *string `json:"password,omitempty"`
	// Jamf Pro username (BASIC strategy).
	Username *string `json:"username,omitempty"`
}

JamfProCredentials Jamf Pro connection credentials. Provide the OAuth pair (`clientId` + `clientSecret`) when `authStrategy` is `JAMF_PRO_OAUTH`, or the basic pair (`username` + `password`) when `authStrategy` is `BASIC`. Omit entirely for `M2M`.

type JamfSchoolConnectorCreateRequest

type JamfSchoolConnectorCreateRequest struct {
	// Jamf School API key.
	// Write-only. Servers MUST NOT return this field in responses; the SDK preserves it only so the caller
	// can supply a value on update.
	ApiKey string `json:"apiKey"`
	// ISO country code for the UEM instance, when applicable.
	IsoCountry *string `json:"isoCountry,omitempty"`
	// Jamf School network id.
	NetworkID string `json:"networkId"`
	// Jamf School server URL.
	URL string `json:"url"`
	// UEM vendor discriminator.
	// Allowed values: see the JamfSchoolConnectorCreateRequestVendor constants.
	Vendor string `json:"vendor"`
}

JamfSchoolConnectorCreateRequest Connector creation request for Jamf School.

type JamfSchoolConnectorCreateRequestVendor

type JamfSchoolConnectorCreateRequestVendor = string

JamfSchoolConnectorCreateRequestVendor is the set of values accepted by JamfSchoolConnectorCreateRequest.Vendor.

const (
	JamfSchoolConnectorCreateRequestVendorJamfSchool JamfSchoolConnectorCreateRequestVendor = "JAMF_SCHOOL"
)

JamfSchoolConnectorCreateRequestVendor values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func JamfSchoolConnectorCreateRequestVendorValues

func JamfSchoolConnectorCreateRequestVendorValues() []JamfSchoolConnectorCreateRequestVendor

JamfSchoolConnectorCreateRequestVendorValues returns every value the Jamf API accepts for JamfSchoolConnectorCreateRequestVendor, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type LatestSync

type LatestSync struct {
	// Why the most recent sync failed. Always present, with null members when the sync did not fail.
	ErrorDetails *SyncErrorDetails `json:"errorDetails,omitempty"`
	// Timestamp when sync completed (ISO 8601), null if still running.
	Finished *time.Time `json:"finished,omitempty"`
	// `finished` as epoch milliseconds. Deprecated duplicate — prefer the ISO-8601 `finished`.
	FinishedUtcMs *int64 `json:"finishedUtcMs,omitempty"`
	// Timestamp of the last progress heartbeat from the running sync (ISO 8601), used to detect stalled
	// syncs.
	LastSeen *time.Time `json:"lastSeen,omitempty"`
	// What triggered this sync.
	// Allowed values: see the LatestSyncRefreshType constants.
	RefreshType *string `json:"refreshType,omitempty"`
	// Timestamp when sync started (ISO 8601).
	Started *time.Time `json:"started,omitempty"`
	// `started` as epoch milliseconds. Deprecated duplicate — prefer the ISO-8601 `started`.
	StartedUtcMs *int64 `json:"startedUtcMs,omitempty"`
	// Current sync status.
	// Allowed values: see the LatestSyncStatus constants.
	Status string `json:"status"`
	// Unique identifier for this sync run. Always present when `latestSync` itself is present: it is the
	// identifier of the underlying sync transaction, and the whole object is null when there is no
	// transaction.
	TransactionID string `json:"transactionId"`
}

LatestSync Summary of the connector's most recent sync run, embedded in `ConnectorConfig`. The containing `latestSync` property is `null` until the connector has run its first sync. This is **not** the same shape as the `SyncRun` entries returned by `GET /connectors/{configId}/sync/runs`: it carries `lastSeen` and `errorDetails`, and has no per-run device counters, because the connector record keeps only the current transaction's state and not its tallies. Use the sync-runs endpoint for run history and counts. `startedUtcMs` and `finishedUtcMs` are retained, deprecated epoch-millisecond duplicates of the ISO-8601 `started` and `finished`. They are still emitted for existing consumers; new consumers should read the ISO-8601 fields.

type LatestSyncRefreshType

type LatestSyncRefreshType = string

LatestSyncRefreshType is the set of values accepted by LatestSync.RefreshType.

const (
	LatestSyncRefreshTypeAuto         LatestSyncRefreshType = "AUTO"
	LatestSyncRefreshTypeManual       LatestSyncRefreshType = "MANUAL"
	LatestSyncRefreshTypeOutOfBand    LatestSyncRefreshType = "OUT_OF_BAND"
	LatestSyncRefreshTypeUemAdHocSync LatestSyncRefreshType = "UEM_AD_HOC_SYNC"
)

LatestSyncRefreshType values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func LatestSyncRefreshTypeValues

func LatestSyncRefreshTypeValues() []LatestSyncRefreshType

LatestSyncRefreshTypeValues returns every value the Jamf API accepts for LatestSyncRefreshType, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type LatestSyncStatus

type LatestSyncStatus = string

LatestSyncStatus is the set of values accepted by LatestSync.Status.

const (
	LatestSyncStatusNotSynchronized      LatestSyncStatus = "NOT_SYNCHRONIZED"
	LatestSyncStatusRunning              LatestSyncStatus = "RUNNING"
	LatestSyncStatusCanceling            LatestSyncStatus = "CANCELING"
	LatestSyncStatusCanceled             LatestSyncStatus = "CANCELED"
	LatestSyncStatusCompleted            LatestSyncStatus = "COMPLETED"
	LatestSyncStatusFailed               LatestSyncStatus = "FAILED"
	LatestSyncStatusAuthFailed           LatestSyncStatus = "AUTH_FAILED"
	LatestSyncStatusConnectionTestFailed LatestSyncStatus = "CONNECTION_TEST_FAILED"
	LatestSyncStatusCompletedWithErrors  LatestSyncStatus = "COMPLETED_WITH_ERRORS"
	LatestSyncStatusStalled              LatestSyncStatus = "STALLED"
)

LatestSyncStatus values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func LatestSyncStatusValues

func LatestSyncStatusValues() []LatestSyncStatus

LatestSyncStatusValues returns every value the Jamf API accepts for LatestSyncStatus, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type Maas360ConnectorCreateRequest

type Maas360ConnectorCreateRequest struct {
	// MaaS360 application access key.
	// Write-only. Servers MUST NOT return this field in responses; the SDK preserves it only so the caller
	// can supply a value on update.
	AppAccessKey string `json:"appAccessKey"`
	// MaaS360 registered application id.
	AppID string `json:"appId"`
	// MaaS360 registered application version.
	AppVersion string `json:"appVersion"`
	// MaaS360 billing (account) id.
	BillingID string `json:"billingId"`
	// MaaS360 API password.
	// Write-only. Servers MUST NOT return this field in responses; the SDK preserves it only so the caller
	// can supply a value on update.
	EmmPassword string `json:"emmPassword"`
	// MaaS360 API username.
	EmmUsername string `json:"emmUsername"`
	// ISO country code for the UEM instance, when applicable.
	IsoCountry *string `json:"isoCountry,omitempty"`
	// MaaS360 server URL.
	URL string `json:"url"`
	// UEM vendor discriminator.
	// Allowed values: see the Maas360ConnectorCreateRequestVendor constants.
	Vendor string `json:"vendor"`
}

Maas360ConnectorCreateRequest Connector creation request for IBM MaaS360.

type Maas360ConnectorCreateRequestVendor

type Maas360ConnectorCreateRequestVendor = string

Maas360ConnectorCreateRequestVendor is the set of values accepted by Maas360ConnectorCreateRequest.Vendor.

const (
	Maas360ConnectorCreateRequestVendorMaas360 Maas360ConnectorCreateRequestVendor = "MAAS360"
)

Maas360ConnectorCreateRequestVendor values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func Maas360ConnectorCreateRequestVendorValues

func Maas360ConnectorCreateRequestVendorValues() []Maas360ConnectorCreateRequestVendor

Maas360ConnectorCreateRequestVendorValues returns every value the Jamf API accepts for Maas360ConnectorCreateRequestVendor, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type Mapping

type Mapping struct {
	// IPv4 (A record) addresses the hostname resolves to. May be null or absent when no IPv4 records are
	// configured. Maximum 10 entries.
	ARecords *[]string `json:"aRecords,omitempty"`
	// IPv6 (AAAA record) addresses the hostname resolves to. May be null or absent when no IPv6 records
	// are configured. Maximum 10 entries.
	AaaaRecords *[]string `json:"aaaaRecords,omitempty"`
	// The fully qualified hostname this mapping applies to.
	Hostname string `json:"hostname"`
	// Whether Secure DNS (DoH/DoT) is enabled for this mapping.
	SecureDns *bool `json:"secureDns,omitempty"`
	// Whether this mapping is routed through Zero Trust Network Access (ZTNA).
	Ztna *bool `json:"ztna,omitempty"`
}

Mapping A custom hostname mapping that overrides DNS resolution for a host.

type MappingList

type MappingList struct {
	// The custom hostname mappings. Contains at most 500 entries.
	Results []Mapping `json:"results"`
	// Total number of custom hostname mappings returned.
	TotalCount int `json:"totalCount"`
}

MappingList A list of custom hostname mappings for the tenant, returned with the standard collection envelope. `totalCount` is server-computed and ignored on write.

type MobileIronCloudConnectorCreateRequest

type MobileIronCloudConnectorCreateRequest struct {
	// MobileIron Cloud API password.
	// Write-only. Servers MUST NOT return this field in responses; the SDK preserves it only so the caller
	// can supply a value on update.
	EmmPassword string `json:"emmPassword"`
	// MobileIron Cloud API username.
	EmmUsername string `json:"emmUsername"`
	// ISO country code for the UEM instance, when applicable.
	IsoCountry *string `json:"isoCountry,omitempty"`
	// MobileIron Cloud server URL.
	URL string `json:"url"`
	// UEM vendor discriminator.
	// Allowed values: see the MobileIronCloudConnectorCreateRequestVendor constants.
	Vendor string `json:"vendor"`
}

MobileIronCloudConnectorCreateRequest Connector creation request for Ivanti Neurons for MDM (MobileIron Cloud). Note: the `vendor` discriminator value is `MOBILEIRONCLOUD`.

type MobileIronCloudConnectorCreateRequestVendor

type MobileIronCloudConnectorCreateRequestVendor = string

MobileIronCloudConnectorCreateRequestVendor is the set of values accepted by MobileIronCloudConnectorCreateRequest.Vendor.

const (
	MobileIronCloudConnectorCreateRequestVendorMobileironcloud MobileIronCloudConnectorCreateRequestVendor = "MOBILEIRONCLOUD"
)

MobileIronCloudConnectorCreateRequestVendor values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func MobileIronCloudConnectorCreateRequestVendorValues

func MobileIronCloudConnectorCreateRequestVendorValues() []MobileIronCloudConnectorCreateRequestVendor

MobileIronCloudConnectorCreateRequestVendorValues returns every value the Jamf API accepts for MobileIronCloudConnectorCreateRequestVendor, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type MobileIronCoreConnectorCreateRequest

type MobileIronCoreConnectorCreateRequest struct {
	// MobileIron Core API password.
	// Write-only. Servers MUST NOT return this field in responses; the SDK preserves it only so the caller
	// can supply a value on update.
	EmmPassword string `json:"emmPassword"`
	// MobileIron Core API username.
	EmmUsername string `json:"emmUsername"`
	// ISO country code for the UEM instance, when applicable.
	IsoCountry *string `json:"isoCountry,omitempty"`
	// Optional PEM-encoded root certificate for TLS verification.
	RootCertificate *string `json:"rootCertificate,omitempty"`
	// MobileIron Core server URL.
	URL string `json:"url"`
	// UEM vendor discriminator.
	// Allowed values: see the MobileIronCoreConnectorCreateRequestVendor constants.
	Vendor string `json:"vendor"`
}

MobileIronCoreConnectorCreateRequest Connector creation request for Ivanti EPMM (MobileIron Core). Note: the `vendor` discriminator value is `MOBILEIRONCORE`.

type MobileIronCoreConnectorCreateRequestVendor

type MobileIronCoreConnectorCreateRequestVendor = string

MobileIronCoreConnectorCreateRequestVendor is the set of values accepted by MobileIronCoreConnectorCreateRequest.Vendor.

const (
	MobileIronCoreConnectorCreateRequestVendorMobileironcore MobileIronCoreConnectorCreateRequestVendor = "MOBILEIRONCORE"
)

MobileIronCoreConnectorCreateRequestVendor values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func MobileIronCoreConnectorCreateRequestVendorValues

func MobileIronCoreConnectorCreateRequestVendorValues() []MobileIronCoreConnectorCreateRequestVendor

MobileIronCoreConnectorCreateRequestVendorValues returns every value the Jamf API accepts for MobileIronCoreConnectorCreateRequestVendor, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type NameServer

type NameServer struct {
	// Public identifier for the gateway. This is the public-facing name for the internal route identifier.
	GatewayID string `json:"gatewayId"`
	// IPv4 address of the name server.
	IP string `json:"ip"`
}

NameServer A name server entry that resolves queries for a DNS Zone.

type PredefinedApp

type PredefinedApp struct {
	// Hostnames inherited by Apps that reference this template.
	Hostnames []string `json:"hostnames"`
	// Template ID. Pass as `predefinedAppId` when creating an App.
	ID string `json:"id"`
	// Display name of the predefined SaaS application.
	Name string `json:"name"`
}

PredefinedApp A predefined SaaS application definition. Pass the `id` as `predefinedAppId` when creating an App.

type PredefinedAppListResponse

type PredefinedAppListResponse struct {
	Results []PredefinedApp `json:"results"`
	// Total number of predefined app templates available.
	TotalCount int `json:"totalCount"`
}

PredefinedAppListResponse List of Predefined Apps with a total count.

type PublicApiCapabilities

type PublicApiCapabilities struct {
	// Enable data policy capability.
	DataPolicy *bool `json:"dataPolicy,omitempty"`
	// Enable network security capability.
	NetworkSecurity *bool `json:"networkSecurity,omitempty"`
	// Optional note for this capability configuration.
	Note *string `json:"note,omitempty"`
	// Enable vulnerability management capability.
	VulnerabilityManagement *bool `json:"vulnerabilityManagement,omitempty"`
}

PublicApiCapabilities Capability configuration. At least one capability must be enabled. `networkSecurity` and `vulnerabilityManagement` are coupled and the schema does not say so: they must be both enabled or both disabled, or the create is refused with `400 INVALID_FIELD` on `capabilities` (`networkSecurity and vulnerabilityManagement must both be enabled or both disabled`). Wire-verified 2026-09-01. The `minProperties: 1` requirement is real but is enforced as a business rule rather than field validation: an empty object answers `400` in the service's own envelope (`{"error": "INVALID_INPUT", "message": "Cannot create activation profile with given parameters for customer <uuid>", ...}`), not the `ApiError` shape the spec declares for this status, so nothing here decodes it.

type PublicApiCreateActivationProfileRequest

type PublicApiCreateActivationProfileRequest struct {
	// Capability configuration. At least one capability must be enabled.
	Capabilities PublicApiCapabilities `json:"capabilities"`
	// Optional group ID to associate with the activation profile.
	GroupID *string `json:"groupId,omitempty"`
	// Name of the activation profile.
	Name string `json:"name"`
	// Creation origin.
	// Allowed values: see the PublicApiCreateActivationProfileRequestOrigin constants.
	Origin string `json:"origin"`
	// Target platforms for this activation profile.
	// Allowed values: see the PublicApiCreateActivationProfileRequestPlatforms constants.
	Platforms []string `json:"platforms"`
}

PublicApiCreateActivationProfileRequest Request body for creating a new activation profile via the public API. Three of this schema's declared constraints are not what the server enforces (wire-verified 2026-09-01 against the JSC sandbox tenant, every probe alongside a 200 control in the same invocation). `additionalProperties: false` is not enforced: a request carrying an undeclared key is accepted and answers 201. `capabilities.note`'s `maxLength: 255` is not enforced either — 256 characters are accepted. And `platforms`' `maxItems: 2` is applied after de-duplication, so `["iOS", "MAC", "iOS"]` is three items and answers 201 while a genuinely three-valued list is refused with `size must be between 1 and 2`. What the server does enforce, all as `400 INVALID_FIELD` attributed to a field: `name` non-blank and `maxLength: 100` (`size must be between 0 and 100`), `platforms` non-empty, each platform member in `iOS`/`MAC` — attributed to `platforms[]`, with the brackets — and `origin` present. An `origin` that is present but not `PUBLIC_API` is refused as `Origin not provided.`, which misreports the cause; a genuinely absent `origin` says `Missing required attribute origin.`. `groupId` is not checked for existence: a nonexistent group ID is accepted and answers 201, so a typo produces a profile silently scoped to nothing.

type PublicApiCreateActivationProfileRequestOrigin

type PublicApiCreateActivationProfileRequestOrigin = string

PublicApiCreateActivationProfileRequestOrigin is the set of values accepted by PublicApiCreateActivationProfileRequest.Origin.

const (
	PublicApiCreateActivationProfileRequestOriginPublicApi PublicApiCreateActivationProfileRequestOrigin = "PUBLIC_API"
)

PublicApiCreateActivationProfileRequestOrigin values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func PublicApiCreateActivationProfileRequestOriginValues

func PublicApiCreateActivationProfileRequestOriginValues() []PublicApiCreateActivationProfileRequestOrigin

PublicApiCreateActivationProfileRequestOriginValues returns every value the Jamf API accepts for PublicApiCreateActivationProfileRequestOrigin, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type PublicApiCreateActivationProfileRequestPlatforms

type PublicApiCreateActivationProfileRequestPlatforms = string

PublicApiCreateActivationProfileRequestPlatforms is the set of values accepted by PublicApiCreateActivationProfileRequest.Platforms.

const (
	PublicApiCreateActivationProfileRequestPlatformsIOS PublicApiCreateActivationProfileRequestPlatforms = "iOS"
	PublicApiCreateActivationProfileRequestPlatformsMac PublicApiCreateActivationProfileRequestPlatforms = "MAC"
)

PublicApiCreateActivationProfileRequestPlatforms values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func PublicApiCreateActivationProfileRequestPlatformsValues

func PublicApiCreateActivationProfileRequestPlatformsValues() []PublicApiCreateActivationProfileRequestPlatforms

PublicApiCreateActivationProfileRequestPlatformsValues returns every value the Jamf API accepts for PublicApiCreateActivationProfileRequestPlatforms, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type RiskControls

type RiskControls struct {
	// Whether risk-based access control is active.
	Enabled bool `json:"enabled"`
	// Minimum risk level that triggers access denial.
	// Allowed values: see the RiskControlsLevelThreshold constants.
	LevelThreshold string `json:"levelThreshold"`
	// Whether to notify users when access is blocked by risk controls.
	NotificationsEnabled bool `json:"notificationsEnabled"`
}

RiskControls Risk-based access controls for the App.

type RiskControlsLevelThreshold

type RiskControlsLevelThreshold = string

RiskControlsLevelThreshold is the set of values accepted by RiskControls.LevelThreshold.

const (
	RiskControlsLevelThresholdLow    RiskControlsLevelThreshold = "LOW"
	RiskControlsLevelThresholdMedium RiskControlsLevelThreshold = "MEDIUM"
	RiskControlsLevelThresholdHigh   RiskControlsLevelThreshold = "HIGH"
)

RiskControlsLevelThreshold values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func RiskControlsLevelThresholdValues

func RiskControlsLevelThresholdValues() []RiskControlsLevelThreshold

RiskControlsLevelThresholdValues returns every value the Jamf API accepts for RiskControlsLevelThreshold, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type Routing

type Routing struct {
	// DNS IP resolution preference. Optional. When omitted and `type=CUSTOM`, defaults to `IPv6`.
	// Explicitly set to `IPv4` if your network requires it. **Must be absent (or null) when
	// `type=DIRECT`** — returns `400` if set.
	// Allowed values: see the RoutingDnsIpResolutionType constants.
	DnsIpResolutionType *string `json:"dnsIpResolutionType"`
	// ID of a Gateway or Grouped Gateway. Required when `type=CUSTOM`, must be null/absent when
	// `type=DIRECT`. Gateway IDs are 4-character lowercase hex strings (e.g. `a1b2`); Grouped Gateway IDs
	// are UUIDs (e.g. `3fa85f64-5717-4562-b3fc-2c963f66afa6`).
	GatewayID *string `json:"gatewayId"`
	// `CUSTOM` routes traffic via a ZTNA gateway (`gatewayId` required). `DIRECT` uses default device
	// routing (`gatewayId` must be null/absent). `BLOCK` is not exposed in the public API.
	// Allowed values: see the RoutingType constants.
	Type string `json:"type"`
}

Routing Traffic routing configuration for an App. Correction to `dnsIpResolutionType` above: it is **required** when `type` is `CUSTOM`, not optional, and there is no server-side default. `{"type":"CUSTOM","gatewayId":"a7d2"}` is refused with `400 [INVALID_FIELD] routing: Routing definition is not valid.` on POST and on PATCH alike; adding `"dnsIpResolutionType":"IPv6"` is what makes the same body succeed (wire-verified 2026-08-30). Because PATCH is a JSON merge patch that merges this object field by field, changing `type` requires sending the fields the new type forbids as explicit nulls rather than omitting them. `CUSTOM` to `DIRECT` sending only `{"type":"DIRECT"}` fails, because the merged object keeps the old `gatewayId` and `dnsIpResolutionType`, both of which `DIRECT` refuses; `{"type":"DIRECT","gatewayId":null,"dnsIpResolutionType":null}` succeeds. This schema is listed in `emitNullForOptional` so that a nil pointer marshals as an explicit null and both transitions are expressible — which also means a create sends those keys as null rather than omitting them, a form the endpoint accepts.

type RoutingDnsIpResolutionType

type RoutingDnsIpResolutionType = string

RoutingDnsIpResolutionType is the set of values accepted by Routing.DnsIpResolutionType.

const (
	RoutingDnsIpResolutionTypeIPv4 RoutingDnsIpResolutionType = "IPv4"
	RoutingDnsIpResolutionTypeIPv6 RoutingDnsIpResolutionType = "IPv6"
)

RoutingDnsIpResolutionType values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func RoutingDnsIpResolutionTypeValues

func RoutingDnsIpResolutionTypeValues() []RoutingDnsIpResolutionType

RoutingDnsIpResolutionTypeValues returns every value the Jamf API accepts for RoutingDnsIpResolutionType, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type RoutingOverride

type RoutingOverride struct {
	// Must be a subset of `assignments.inclusions.groups` (or `allUsers: true`). A group ID may not appear
	// in more than one routing override entry — returns `400` on conflict.
	GroupIds []string `json:"groupIds"`
	// Traffic routing configuration for an App.
	Routing Routing `json:"routing"`
}

RoutingOverride A routing override applied to a specific subset of assigned groups.

type RoutingStrategy

type RoutingStrategy = string

RoutingStrategy represents a routing strategy value.

const (
	RoutingStrategyActiveStandby RoutingStrategy = "ACTIVE_STANDBY"
	RoutingStrategyRandom        RoutingStrategy = "RANDOM"
	RoutingStrategyNearest       RoutingStrategy = "NEAREST"
)

RoutingStrategy values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func RoutingStrategyValues

func RoutingStrategyValues() []RoutingStrategy

RoutingStrategyValues returns every value the Jamf API accepts for RoutingStrategy, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type RoutingType

type RoutingType = string

RoutingType is the set of values accepted by Routing.Type.

const (
	RoutingTypeCustom RoutingType = "CUSTOM"
	RoutingTypeDirect RoutingType = "DIRECT"
)

RoutingType values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func RoutingTypeValues

func RoutingTypeValues() []RoutingType

RoutingTypeValues returns every value the Jamf API accepts for RoutingType, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type SearchDomain

type SearchDomain struct {
	// The DNS search suffix appended to unqualified host names. Bounded to the maximum DNS name length of
	// 253 characters (RFC 1035).
	Suffix string `json:"suffix"`
}

SearchDomain The tenant Search Domain — a singleton resource holding a single optional search-domain suffix.

type SharedGateway

type SharedGateway struct {
	// Gateway ID. Format: 4-character lowercase hexadecimal string (e.g. `a1b2`).
	ID string `json:"id"`
	// Human-readable name.
	Name string `json:"name"`
}

SharedGateway A Jamf-managed shared ZTNA Gateway. Read-only. Only VPN route metadata is returned — no deployment details.

type SharedGatewayListResponse

type SharedGatewayListResponse struct {
	Results []SharedGateway `json:"results"`
	// Total number of Shared Gateways available to this tenant.
	TotalCount int `json:"totalCount"`
}

SharedGatewayListResponse List of Shared Gateways with a total count.

type SyncConfig

type SyncConfig struct {
	// Auto-deletion policy for devices removed from the UEM platform.
	// Allowed values: see the SyncConfigAutoDeviceDeletion constants.
	AutoDeviceDeletion string `json:"autoDeviceDeletion"`
	// Whether to automatically disable sync after repeated authentication failures.
	DisableSyncOnAuthError bool `json:"disableSyncOnAuthError"`
}

SyncConfig Sync configuration settings as returned in responses. Response-only: the corresponding update request carries these two settings as **top-level** `autoDeviceDeletion` and `disableSyncOnAuthError` fields on `SyncSettings`, not nested under `syncConfig`.

type SyncConfigAutoDeviceDeletion

type SyncConfigAutoDeviceDeletion = string

SyncConfigAutoDeviceDeletion is the set of values accepted by SyncConfig.AutoDeviceDeletion.

const (
	SyncConfigAutoDeviceDeletionDisabled         SyncConfigAutoDeviceDeletion = "DISABLED"
	SyncConfigAutoDeviceDeletionDeletedOrRetired SyncConfigAutoDeviceDeletion = "DELETED_OR_RETIRED"
	SyncConfigAutoDeviceDeletionUnmanaged        SyncConfigAutoDeviceDeletion = "UNMANAGED"
)

SyncConfigAutoDeviceDeletion values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func SyncConfigAutoDeviceDeletionValues

func SyncConfigAutoDeviceDeletionValues() []SyncConfigAutoDeviceDeletion

SyncConfigAutoDeviceDeletionValues returns every value the Jamf API accepts for SyncConfigAutoDeviceDeletion, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type SyncErrorDetails

type SyncErrorDetails struct {
	// Human-readable failure detail.
	Description *string `json:"description,omitempty"`
	// Coarse failure category.
	// Allowed values: see the SyncErrorDetailsReason constants.
	Reason *string `json:"reason,omitempty"`
}

SyncErrorDetails Why the most recent sync failed. Always present, with null members when the sync did not fail.

type SyncErrorDetailsReason

type SyncErrorDetailsReason = string

SyncErrorDetailsReason is the set of values accepted by SyncErrorDetails.Reason.

const (
	SyncErrorDetailsReasonUnexpectedError SyncErrorDetailsReason = "UNEXPECTED_ERROR"
	SyncErrorDetailsReasonLost            SyncErrorDetailsReason = "LOST"
)

SyncErrorDetailsReason values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func SyncErrorDetailsReasonValues

func SyncErrorDetailsReasonValues() []SyncErrorDetailsReason

SyncErrorDetailsReasonValues returns every value the Jamf API accepts for SyncErrorDetailsReason, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type SyncRun

type SyncRun struct {
	// Connector configuration identifier.
	ConfigID string `json:"configId"`
	// Number of devices removed during this run.
	Deleted int `json:"deleted"`
	// Number of devices that encountered errors during this run.
	Errored int `json:"errored"`
	// Timestamp when sync completed (ISO 8601), null if still running.
	Finished *time.Time `json:"finished,omitempty"`
	// What triggered this sync.
	// Allowed values: see the SyncRunRefreshType constants.
	RefreshType string `json:"refreshType"`
	// Timestamp when sync started (ISO 8601).
	Started *time.Time `json:"started,omitempty"`
	// Current sync status.
	// Allowed values: see the SyncRunStatus constants.
	Status string `json:"status"`
	// Number of devices synced (added or updated) during this run.
	Synced int `json:"synced"`
	// Unique identifier for this sync run.
	TransactionID string `json:"transactionId"`
}

SyncRun Details of a single sync run.

type SyncRunPage

type SyncRunPage struct {
	// The sync runs for the requested page.
	Results []SyncRun `json:"results"`
	// Total number of sync runs across all pages.
	TotalCount int64 `json:"totalCount"`
}

SyncRunPage A page of sync runs.

type SyncRunRefreshType

type SyncRunRefreshType = string

SyncRunRefreshType is the set of values accepted by SyncRun.RefreshType.

const (
	SyncRunRefreshTypeAuto         SyncRunRefreshType = "AUTO"
	SyncRunRefreshTypeManual       SyncRunRefreshType = "MANUAL"
	SyncRunRefreshTypeOutOfBand    SyncRunRefreshType = "OUT_OF_BAND"
	SyncRunRefreshTypeUemAdHocSync SyncRunRefreshType = "UEM_AD_HOC_SYNC"
)

SyncRunRefreshType values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func SyncRunRefreshTypeValues

func SyncRunRefreshTypeValues() []SyncRunRefreshType

SyncRunRefreshTypeValues returns every value the Jamf API accepts for SyncRunRefreshType, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type SyncRunStatus

type SyncRunStatus = string

SyncRunStatus is the set of values accepted by SyncRun.Status.

const (
	SyncRunStatusNotSynchronized      SyncRunStatus = "NOT_SYNCHRONIZED"
	SyncRunStatusRunning              SyncRunStatus = "RUNNING"
	SyncRunStatusCanceling            SyncRunStatus = "CANCELING"
	SyncRunStatusCanceled             SyncRunStatus = "CANCELED"
	SyncRunStatusCompleted            SyncRunStatus = "COMPLETED"
	SyncRunStatusFailed               SyncRunStatus = "FAILED"
	SyncRunStatusAuthFailed           SyncRunStatus = "AUTH_FAILED"
	SyncRunStatusConnectionTestFailed SyncRunStatus = "CONNECTION_TEST_FAILED"
	SyncRunStatusCompletedWithErrors  SyncRunStatus = "COMPLETED_WITH_ERRORS"
	SyncRunStatusStalled              SyncRunStatus = "STALLED"
)

SyncRunStatus values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func SyncRunStatusValues

func SyncRunStatusValues() []SyncRunStatus

SyncRunStatusValues returns every value the Jamf API accepts for SyncRunStatus, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type SyncSettings

type SyncSettings struct {
	// Auto-deletion policy for devices removed from the UEM platform.
	// Allowed values: see the SyncSettingsAutoDeviceDeletion constants.
	AutoDeviceDeletion string `json:"autoDeviceDeletion"`
	// Whether this connector may sync several devices concurrently, for faster inventory updates.
	// Absent from the published spec's update request while present on the response, and writable — a
	// `PUT` carrying `false` persists (wire-verified 2026-08-28). Because the update is a full
	// replacement, a request built from the unpatched spec could not express the field and therefore reset
	// it to `true` on every write, silently discarding an operator's choice.
	ConcurrentSyncEnabled *bool `json:"concurrentSyncEnabled,omitempty"`
	// Controls which UEM attribute each JSC device field is populated from. Each value is an enum of UEM
	// attribute names whose members are vendor-specific, so the accepted values for a given key depend on
	// the connector's `vendor`. The Google connector accepts no mappings.
	DeviceFieldMappings DeviceFieldMappings `json:"deviceFieldMappings"`
	// Whether device risk levels are sent back to UEM.
	DeviceRiskTagging *bool `json:"deviceRiskTagging,omitempty"`
	// Number of days since last check-in before a device is treated as unmanaged. `0` uses the platform
	// default (3 days). Not applicable for JAMF_PRO — any value sent for that vendor is silently ignored
	// (device status is taken exclusively from the UEM).
	// Allowed values: see the SyncSettingsDeviceUnmanagedThreshold constants.
	DeviceUnmanagedThreshold *int `json:"deviceUnmanagedThreshold,omitempty"`
	// Whether to automatically disable sync after repeated authentication failures.
	DisableSyncOnAuthError *bool `json:"disableSyncOnAuthError,omitempty"`
	// Group mapping configuration. Maps UEM groups to JSC groups.
	GroupSettings *GroupSettings `json:"groupSettings,omitempty"`
	// Sync refresh interval in minutes.
	// Allowed values: see the SyncSettingsRefreshRateMinutes constants.
	RefreshRateMinutes *int64 `json:"refreshRateMinutes,omitempty"`
	// Whether scheduled sync is enabled.
	Scheduled *bool `json:"scheduled,omitempty"`
	// UEM vendor name — determines the shape of vendor-specific fields. Must match the stored
	// connector's vendor; a value that disagrees with it is rejected with `422 VENDOR_MISMATCH`. This
	// field selects the applicable vendor-specific fields, it does not change which connector is updated
	// (that is the path `configId`) nor the connector's vendor.
	// Allowed values: see the SyncSettingsVendor constants.
	Vendor string `json:"vendor"`
}

SyncSettings Sync settings update request. Vendor-specific fields may also be included. The `vendor` field in the body determines which additional fields are applicable. This is a **full replacement**, not a patch: omitted optional fields are reset to their defaults rather than left unchanged. Send the complete desired state. Note the asymmetry with the response: `autoDeviceDeletion` and `disableSyncOnAuthError` are top-level here, but are returned nested under `syncConfig` on `ConnectorConfig`. Correction to the full-replacement claim above: `groupSettings` is exempt from it. Omit the whole object and the connector's existing group mapping configuration survives untouched; every other optional field omitted here resets to its default (wire-verified 2026-08-28 — probed from non-default state, since a connector already sitting at its defaults makes a full replacement indistinguishable from a merge). Within `groupSettings` the replacement rule applies again: an omitted `defaultGroupId` clears, and `groupMappings` replaces the whole list.

type SyncSettingsAutoDeviceDeletion

type SyncSettingsAutoDeviceDeletion = string

SyncSettingsAutoDeviceDeletion is the set of values accepted by SyncSettings.AutoDeviceDeletion.

const (
	SyncSettingsAutoDeviceDeletionDisabled         SyncSettingsAutoDeviceDeletion = "DISABLED"
	SyncSettingsAutoDeviceDeletionDeletedOrRetired SyncSettingsAutoDeviceDeletion = "DELETED_OR_RETIRED"
	SyncSettingsAutoDeviceDeletionUnmanaged        SyncSettingsAutoDeviceDeletion = "UNMANAGED"
)

SyncSettingsAutoDeviceDeletion values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func SyncSettingsAutoDeviceDeletionValues

func SyncSettingsAutoDeviceDeletionValues() []SyncSettingsAutoDeviceDeletion

SyncSettingsAutoDeviceDeletionValues returns every value the Jamf API accepts for SyncSettingsAutoDeviceDeletion, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type SyncSettingsDeviceUnmanagedThreshold

type SyncSettingsDeviceUnmanagedThreshold = int

SyncSettingsDeviceUnmanagedThreshold is the set of values accepted by SyncSettings.DeviceUnmanagedThreshold.

const (
	SyncSettingsDeviceUnmanagedThreshold0  SyncSettingsDeviceUnmanagedThreshold = 0
	SyncSettingsDeviceUnmanagedThreshold1  SyncSettingsDeviceUnmanagedThreshold = 1
	SyncSettingsDeviceUnmanagedThreshold3  SyncSettingsDeviceUnmanagedThreshold = 3
	SyncSettingsDeviceUnmanagedThreshold5  SyncSettingsDeviceUnmanagedThreshold = 5
	SyncSettingsDeviceUnmanagedThreshold7  SyncSettingsDeviceUnmanagedThreshold = 7
	SyncSettingsDeviceUnmanagedThreshold14 SyncSettingsDeviceUnmanagedThreshold = 14
)

SyncSettingsDeviceUnmanagedThreshold values accepted by the Jamf API. The alias above is an int, so these constants pass to any parameter or field declared as a plain int.

func SyncSettingsDeviceUnmanagedThresholdValues

func SyncSettingsDeviceUnmanagedThresholdValues() []SyncSettingsDeviceUnmanagedThreshold

SyncSettingsDeviceUnmanagedThresholdValues returns every value the Jamf API accepts for SyncSettingsDeviceUnmanagedThreshold, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's int64validator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type SyncSettingsRefreshRateMinutes

type SyncSettingsRefreshRateMinutes = int64

SyncSettingsRefreshRateMinutes is the set of values accepted by SyncSettings.RefreshRateMinutes.

const (
	SyncSettingsRefreshRateMinutes60   SyncSettingsRefreshRateMinutes = 60
	SyncSettingsRefreshRateMinutes120  SyncSettingsRefreshRateMinutes = 120
	SyncSettingsRefreshRateMinutes240  SyncSettingsRefreshRateMinutes = 240
	SyncSettingsRefreshRateMinutes480  SyncSettingsRefreshRateMinutes = 480
	SyncSettingsRefreshRateMinutes720  SyncSettingsRefreshRateMinutes = 720
	SyncSettingsRefreshRateMinutes1440 SyncSettingsRefreshRateMinutes = 1440
)

SyncSettingsRefreshRateMinutes values accepted by the Jamf API. The alias above is an int64, so these constants pass to any parameter or field declared as a plain int64.

func SyncSettingsRefreshRateMinutesValues

func SyncSettingsRefreshRateMinutesValues() []SyncSettingsRefreshRateMinutes

SyncSettingsRefreshRateMinutesValues returns every value the Jamf API accepts for SyncSettingsRefreshRateMinutes, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's int64validator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type SyncSettingsVendor

type SyncSettingsVendor = string

SyncSettingsVendor is the set of values accepted by SyncSettings.Vendor.

const (
	SyncSettingsVendorIntune          SyncSettingsVendor = "INTUNE"
	SyncSettingsVendorXenmobile       SyncSettingsVendor = "XENMOBILE"
	SyncSettingsVendorMaas360         SyncSettingsVendor = "MAAS360"
	SyncSettingsVendorAirwatch        SyncSettingsVendor = "AIRWATCH"
	SyncSettingsVendorJamfPro         SyncSettingsVendor = "JAMF_PRO"
	SyncSettingsVendorJamfSchool      SyncSettingsVendor = "JAMF_SCHOOL"
	SyncSettingsVendorMobileironcloud SyncSettingsVendor = "MOBILEIRONCLOUD"
	SyncSettingsVendorMobileironcore  SyncSettingsVendor = "MOBILEIRONCORE"
	SyncSettingsVendorGoogle          SyncSettingsVendor = "GOOGLE"
	SyncSettingsVendorWizy            SyncSettingsVendor = "WIZY"
)

SyncSettingsVendor values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func SyncSettingsVendorValues

func SyncSettingsVendorValues() []SyncSettingsVendor

SyncSettingsVendorValues returns every value the Jamf API accepts for SyncSettingsVendor, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type UpdateGroupRequest

type UpdateGroupRequest struct {
	// New name for the group.
	Name string `json:"name"`
}

UpdateGroupRequest Request body for updating an existing device group.

type WizyConnectorCreateRequest

type WizyConnectorCreateRequest struct {
	// ISO country code for the UEM instance, when applicable.
	IsoCountry *string `json:"isoCountry,omitempty"`
	// Wizy namespace.
	Namespace string `json:"namespace"`
	// Wizy server URL.
	URL string `json:"url"`
	// UEM vendor discriminator.
	// Allowed values: see the WizyConnectorCreateRequestVendor constants.
	Vendor string `json:"vendor"`
}

WizyConnectorCreateRequest Connector creation request for Wizy.

type WizyConnectorCreateRequestVendor

type WizyConnectorCreateRequestVendor = string

WizyConnectorCreateRequestVendor is the set of values accepted by WizyConnectorCreateRequest.Vendor.

const (
	WizyConnectorCreateRequestVendorWizy WizyConnectorCreateRequestVendor = "WIZY"
)

WizyConnectorCreateRequestVendor values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func WizyConnectorCreateRequestVendorValues

func WizyConnectorCreateRequestVendorValues() []WizyConnectorCreateRequestVendor

WizyConnectorCreateRequestVendorValues returns every value the Jamf API accepts for WizyConnectorCreateRequestVendor, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type WorkspaceOneConnectorCreateRequest

type WorkspaceOneConnectorCreateRequest struct {
	// Workspace ONE API password.
	// Write-only. Servers MUST NOT return this field in responses; the SDK preserves it only so the caller
	// can supply a value on update.
	EmmPassword string `json:"emmPassword"`
	// Workspace ONE API username.
	EmmUsername string `json:"emmUsername"`
	// ISO country code for the UEM instance, when applicable.
	IsoCountry *string `json:"isoCountry,omitempty"`
	// Optional PEM-encoded root certificate for TLS verification.
	RootCertificate *string `json:"rootCertificate,omitempty"`
	// Workspace ONE REST API tenant code (aw-tenant-code).
	// Write-only. Servers MUST NOT return this field in responses; the SDK preserves it only so the caller
	// can supply a value on update.
	TenantCode string `json:"tenantCode"`
	// Workspace ONE server URL.
	URL string `json:"url"`
	// UEM vendor discriminator.
	// Allowed values: see the WorkspaceOneConnectorCreateRequestVendor constants.
	Vendor string `json:"vendor"`
}

WorkspaceOneConnectorCreateRequest Connector creation request for VMware Workspace ONE. Note: the `vendor` discriminator value is `AIRWATCH`, the identifier the service uses for Workspace ONE (formerly AirWatch).

type WorkspaceOneConnectorCreateRequestVendor

type WorkspaceOneConnectorCreateRequestVendor = string

WorkspaceOneConnectorCreateRequestVendor is the set of values accepted by WorkspaceOneConnectorCreateRequest.Vendor.

const (
	WorkspaceOneConnectorCreateRequestVendorAirwatch WorkspaceOneConnectorCreateRequestVendor = "AIRWATCH"
)

WorkspaceOneConnectorCreateRequestVendor values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func WorkspaceOneConnectorCreateRequestVendorValues

func WorkspaceOneConnectorCreateRequestVendorValues() []WorkspaceOneConnectorCreateRequestVendor

WorkspaceOneConnectorCreateRequestVendorValues returns every value the Jamf API accepts for WorkspaceOneConnectorCreateRequestVendor, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type XenMobileConnectorCreateRequest

type XenMobileConnectorCreateRequest struct {
	// Authentication strategy used to connect to XenMobile. See the schema description for the fields each
	// strategy requires.
	// Allowed values: see the XenMobileConnectorCreateRequestAuthStrategy constants.
	AuthStrategy string `json:"authStrategy"`
	// Citrix Cloud administrator credentials for the CITRIX_CLOUD_ADMIN strategy.
	CitrixCloudConfig *CitrixCloudConfig `json:"citrixCloudConfig,omitempty"`
	// Citrix Cloud OAuth credentials for the CITRIX_CLOUD_ADMIN_OAUTH strategy.
	CitrixCloudOauthConfig *CitrixCloudOauthConfig `json:"citrixCloudOauthConfig,omitempty"`
	// XenMobile password (USERNAME_PASSWORD strategy).
	// Write-only. Servers MUST NOT return this field in responses; the SDK preserves it only so the caller
	// can supply a value on update.
	EmmPassword *string `json:"emmPassword,omitempty"`
	// XenMobile username (USERNAME_PASSWORD strategy).
	EmmUsername *string `json:"emmUsername,omitempty"`
	// ISO country code for the UEM instance, when applicable.
	IsoCountry *string `json:"isoCountry,omitempty"`
	// XenMobile server URL.
	URL string `json:"url"`
	// UEM vendor discriminator.
	// Allowed values: see the XenMobileConnectorCreateRequestVendor constants.
	Vendor string `json:"vendor"`
}

XenMobileConnectorCreateRequest Connector creation request for Citrix Endpoint Management (XenMobile). The `authStrategy` field selects the authentication method and determines which further fields are required: - `USERNAME_PASSWORD` — provide `emmUsername` and `emmPassword`. - `CITRIX_CLOUD_ADMIN` — provide `citrixCloudConfig`. - `CITRIX_CLOUD_ADMIN_OAUTH` — provide `citrixCloudOauthConfig`.

type XenMobileConnectorCreateRequestAuthStrategy

type XenMobileConnectorCreateRequestAuthStrategy = string

XenMobileConnectorCreateRequestAuthStrategy is the set of values accepted by XenMobileConnectorCreateRequest.AuthStrategy.

const (
	XenMobileConnectorCreateRequestAuthStrategyUsernamePassword      XenMobileConnectorCreateRequestAuthStrategy = "USERNAME_PASSWORD"
	XenMobileConnectorCreateRequestAuthStrategyCitrixCloudAdmin      XenMobileConnectorCreateRequestAuthStrategy = "CITRIX_CLOUD_ADMIN"
	XenMobileConnectorCreateRequestAuthStrategyCitrixCloudAdminOauth XenMobileConnectorCreateRequestAuthStrategy = "CITRIX_CLOUD_ADMIN_OAUTH"
)

XenMobileConnectorCreateRequestAuthStrategy values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func XenMobileConnectorCreateRequestAuthStrategyValues

func XenMobileConnectorCreateRequestAuthStrategyValues() []XenMobileConnectorCreateRequestAuthStrategy

XenMobileConnectorCreateRequestAuthStrategyValues returns every value the Jamf API accepts for XenMobileConnectorCreateRequestAuthStrategy, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type XenMobileConnectorCreateRequestVendor

type XenMobileConnectorCreateRequestVendor = string

XenMobileConnectorCreateRequestVendor is the set of values accepted by XenMobileConnectorCreateRequest.Vendor.

const (
	XenMobileConnectorCreateRequestVendorXenmobile XenMobileConnectorCreateRequestVendor = "XENMOBILE"
)

XenMobileConnectorCreateRequestVendor values accepted by the Jamf API. The alias above is a string, so these constants pass to any parameter or field declared as a plain string.

func XenMobileConnectorCreateRequestVendorValues

func XenMobileConnectorCreateRequestVendorValues() []XenMobileConnectorCreateRequestVendor

XenMobileConnectorCreateRequestVendorValues returns every value the Jamf API accepts for XenMobileConnectorCreateRequestVendor, in the order the spec declares them. Returns a fresh slice per call, so no caller can corrupt the set for the rest of the process — which a package level var would allow. Suits attribute validation (Terraform's stringvalidator.OneOf, say) and anything that needs to enumerate the set rather than name one member.

type Zone

type Zone struct {
	// The list of domains served by this DNS Zone.
	Domains []string `json:"domains"`
	// Server-assigned unique identifier of the DNS Zone.
	ID string `json:"id"`
	// Human-readable name of the DNS Zone. Maximum length 100 characters.
	Name string `json:"name"`
	// The list of name servers that resolve queries for this Zone.
	NameServers []NameServer `json:"nameServers"`
}

Zone A DNS Zone configured for the tenant.

type ZoneList

type ZoneList struct {
	// The DNS Zones for the tenant.
	Results []Zone `json:"results"`
	// Total number of DNS Zones returned in the list.
	TotalCount int `json:"totalCount"`
}

ZoneList A list of DNS Zones for the tenant.

type ZonePatch

type ZonePatch struct {
	// Updated list of domains served by this DNS Zone. Omit to leave unchanged.
	Domains *[]string `json:"domains,omitempty"`
	// Updated name of the DNS Zone. 1 to 100 characters when supplied. Omit to leave unchanged.
	Name *string `json:"name,omitempty"`
	// Updated list of name servers for this Zone. Omit to leave unchanged.
	NameServers *[]NameServer `json:"nameServers,omitempty"`
}

ZonePatch JSON Merge Patch (RFC 7396) request body for updating a DNS Zone. Any subset of the writable Zone fields may be supplied; omitted fields are left unchanged. A field set to `null` clears it where the field is optional; setting a required field to `null` is rejected (400, per ADG-302).

type ZoneRef

type ZoneRef struct {
	// Canonical URL of the DNS Zone.
	Href string `json:"href"`
	// Server-assigned unique identifier of the DNS Zone.
	ID string `json:"id"`
}

ZoneRef A reference to a DNS Zone, returned upon creation.

type ZoneWrite

type ZoneWrite struct {
	// The list of domains served by this DNS Zone. Must contain between 1 and 100 entries.
	Domains []string `json:"domains"`
	// Human-readable name of the DNS Zone. 1 to 100 characters.
	Name string `json:"name"`
	// The list of name servers that resolve queries for this Zone. Must contain between 1 and 20 entries.
	NameServers []NameServer `json:"nameServers"`
}

ZoneWrite Request body for creating a DNS Zone.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL