proclassic

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: 10 Imported by: 0

Documentation

Overview

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

Index

Constants

This section is empty.

Variables

View Source 
var Privileges = map[string]jamfplatform.MethodPrivileges{}/* 589 elements not displayed */

Privileges maps each proclassic 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 Account 

type Account struct {
	XMLName xml.Name
	// Allowed values: see the AccountAccessLevel constants.
	AccessLevel   *string `xml:"access_level,omitempty"`
	DirectoryUser *bool   `xml:"directory_user,omitempty"`
	Email         *string `xml:"email,omitempty"`
	EmailAddress  *string `xml:"email_address,omitempty"`
	// Allowed values: see the AccountEnabled constants.
	Enabled             *string            `xml:"enabled,omitempty"`
	ForcePasswordChange *bool              `xml:"force_password_change,omitempty"`
	FullName            *string            `xml:"full_name,omitempty"`
	Groups              *AccountGroups     `xml:"groups,omitempty"`
	ID                  *int               `xml:"id,omitempty"`
	LdapServer          *AccountLdapServer `xml:"ldap_server,omitempty"`
	// Name of the account.
	Name *string `xml:"name,omitempty"`
	// 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 `xml:"password,omitempty"`
	PasswordSha256 *string `xml:"password_sha256,omitempty"`
	// Allowed values: see the AccountPrivilegeSet constants.
	PrivilegeSet *string            `xml:"privilege_set,omitempty"`
	Privileges   *AccountPrivileges `xml:"privileges,omitempty"`
	Site         *SiteObject        `xml:"site,omitempty"`
}

Account represents a account.

func (Account) MarshalXML 

func (t Account) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Account root element name to the wire value declared by the spec (<account>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountAccessLevel 

type AccountAccessLevel = string

AccountAccessLevel is the set of values accepted by Account.AccessLevel. 

const (
	AccountAccessLevelFullAccess  AccountAccessLevel = "Full Access"
	AccountAccessLevelSiteAccess  AccountAccessLevel = "Site Access"
	AccountAccessLevelGroupAccess AccountAccessLevel = "Group Access"
)

AccountAccessLevel 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 AccountAccessLevelValues 

func AccountAccessLevelValues() []AccountAccessLevel

AccountAccessLevelValues returns every value the Jamf API accepts for AccountAccessLevel, 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 AccountEnabled 

type AccountEnabled = string

AccountEnabled is the set of values accepted by Account.Enabled. 

const (
	AccountEnabledEnabled  AccountEnabled = "Enabled"
	AccountEnabledDisabled AccountEnabled = "Disabled"
)

AccountEnabled 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 AccountEnabledValues 

func AccountEnabledValues() []AccountEnabled

AccountEnabledValues returns every value the Jamf API accepts for AccountEnabled, 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 AccountGroups 

type AccountGroups struct {
	XMLName xml.Name
	Group   *[]AccountGroupsGroupItem `xml:"group,omitempty"`
}

AccountGroups represents a account groups.

func (AccountGroups) MarshalXML 

func (t AccountGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountGroups root element name to the wire value declared by the spec (<groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountGroupsGroupItem 

type AccountGroupsGroupItem struct {
	XMLName    xml.Name
	ID         *int                              `xml:"id,omitempty"`
	Name       *string                           `xml:"name,omitempty"`
	Privileges *AccountGroupsGroupItemPrivileges `xml:"privileges,omitempty"`
	Site       *Site                             `xml:"site,omitempty"`
}

AccountGroupsGroupItem represents a account groups group item.

func (AccountGroupsGroupItem) MarshalXML 

func (t AccountGroupsGroupItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountGroupsGroupItem root element name to the wire value declared by the spec (<group>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountGroupsGroupItemPrivileges 

type AccountGroupsGroupItemPrivileges struct {
	XMLName       xml.Name
	ID            *int                                           `xml:"id,omitempty"`
	CasperAdmin   *AccountGroupsGroupItemPrivilegesCasperAdmin   `xml:"casper_admin,omitempty"`
	CasperImaging *AccountGroupsGroupItemPrivilegesCasperImaging `xml:"casper_imaging,omitempty"`
	CasperRemote  *AccountGroupsGroupItemPrivilegesCasperRemote  `xml:"casper_remote,omitempty"`
	JssActions    *AccountGroupsGroupItemPrivilegesJssActions    `xml:"jss_actions,omitempty"`
	JssObjects    *AccountGroupsGroupItemPrivilegesJssObjects    `xml:"jss_objects,omitempty"`
	JssSettings   *AccountGroupsGroupItemPrivilegesJssSettings   `xml:"jss_settings,omitempty"`
	Recon         *AccountGroupsGroupItemPrivilegesRecon         `xml:"recon,omitempty"`
}

AccountGroupsGroupItemPrivileges represents a account groups group item privileges.

func (AccountGroupsGroupItemPrivileges) MarshalXML 

func (t AccountGroupsGroupItemPrivileges) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountGroupsGroupItemPrivileges root element name to the wire value declared by the spec (<privileges>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountGroupsGroupItemPrivilegesCasperAdmin 

type AccountGroupsGroupItemPrivilegesCasperAdmin struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

AccountGroupsGroupItemPrivilegesCasperAdmin represents a account groups group item privileges casper admin.

func (AccountGroupsGroupItemPrivilegesCasperAdmin) MarshalXML 

func (t AccountGroupsGroupItemPrivilegesCasperAdmin) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountGroupsGroupItemPrivilegesCasperAdmin root element name to the wire value declared by the spec (<casper_admin>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountGroupsGroupItemPrivilegesCasperImaging 

type AccountGroupsGroupItemPrivilegesCasperImaging struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

AccountGroupsGroupItemPrivilegesCasperImaging represents a account groups group item privileges casper imaging.

func (AccountGroupsGroupItemPrivilegesCasperImaging) MarshalXML 

func (t AccountGroupsGroupItemPrivilegesCasperImaging) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountGroupsGroupItemPrivilegesCasperImaging root element name to the wire value declared by the spec (<casper_imaging>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountGroupsGroupItemPrivilegesCasperRemote 

type AccountGroupsGroupItemPrivilegesCasperRemote struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

AccountGroupsGroupItemPrivilegesCasperRemote represents a account groups group item privileges casper remote.

func (AccountGroupsGroupItemPrivilegesCasperRemote) MarshalXML 

func (t AccountGroupsGroupItemPrivilegesCasperRemote) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountGroupsGroupItemPrivilegesCasperRemote root element name to the wire value declared by the spec (<casper_remote>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountGroupsGroupItemPrivilegesJssActions 

type AccountGroupsGroupItemPrivilegesJssActions struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

AccountGroupsGroupItemPrivilegesJssActions represents a account groups group item privileges jss actions.

func (AccountGroupsGroupItemPrivilegesJssActions) MarshalXML 

func (t AccountGroupsGroupItemPrivilegesJssActions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountGroupsGroupItemPrivilegesJssActions root element name to the wire value declared by the spec (<jss_actions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountGroupsGroupItemPrivilegesJssObjects 

type AccountGroupsGroupItemPrivilegesJssObjects struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

AccountGroupsGroupItemPrivilegesJssObjects represents a account groups group item privileges jss objects.

func (AccountGroupsGroupItemPrivilegesJssObjects) MarshalXML 

func (t AccountGroupsGroupItemPrivilegesJssObjects) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountGroupsGroupItemPrivilegesJssObjects root element name to the wire value declared by the spec (<jss_objects>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountGroupsGroupItemPrivilegesJssSettings 

type AccountGroupsGroupItemPrivilegesJssSettings struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

AccountGroupsGroupItemPrivilegesJssSettings represents a account groups group item privileges jss settings.

func (AccountGroupsGroupItemPrivilegesJssSettings) MarshalXML 

func (t AccountGroupsGroupItemPrivilegesJssSettings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountGroupsGroupItemPrivilegesJssSettings root element name to the wire value declared by the spec (<jss_settings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountGroupsGroupItemPrivilegesRecon 

type AccountGroupsGroupItemPrivilegesRecon struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

AccountGroupsGroupItemPrivilegesRecon represents a account groups group item privileges recon.

func (AccountGroupsGroupItemPrivilegesRecon) MarshalXML 

func (t AccountGroupsGroupItemPrivilegesRecon) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountGroupsGroupItemPrivilegesRecon root element name to the wire value declared by the spec (<recon>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountLdapServer 

type AccountLdapServer struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
}

AccountLdapServer represents a account ldap server.

func (AccountLdapServer) MarshalXML 

func (t AccountLdapServer) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountLdapServer root element name to the wire value declared by the spec (<ldap_server>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountPrivilegeSet 

type AccountPrivilegeSet = string

AccountPrivilegeSet is the set of values accepted by Account.PrivilegeSet. 

const (
	AccountPrivilegeSetAdministrator  AccountPrivilegeSet = "Administrator"
	AccountPrivilegeSetAuditor        AccountPrivilegeSet = "Auditor"
	AccountPrivilegeSetEnrollmentOnly AccountPrivilegeSet = "Enrollment Only"
	AccountPrivilegeSetCustom         AccountPrivilegeSet = "Custom"
)

AccountPrivilegeSet 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 AccountPrivilegeSetValues 

func AccountPrivilegeSetValues() []AccountPrivilegeSet

AccountPrivilegeSetValues returns every value the Jamf API accepts for AccountPrivilegeSet, 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 AccountPrivileges 

type AccountPrivileges struct {
	XMLName       xml.Name
	ID            *int                            `xml:"id,omitempty"`
	CasperAdmin   *AccountPrivilegesCasperAdmin   `xml:"casper_admin,omitempty"`
	CasperImaging *AccountPrivilegesCasperImaging `xml:"casper_imaging,omitempty"`
	CasperRemote  *AccountPrivilegesCasperRemote  `xml:"casper_remote,omitempty"`
	JssActions    *AccountPrivilegesJssActions    `xml:"jss_actions,omitempty"`
	JssObjects    *AccountPrivilegesJssObjects    `xml:"jss_objects,omitempty"`
	JssSettings   *AccountPrivilegesJssSettings   `xml:"jss_settings,omitempty"`
	Recon         *AccountPrivilegesRecon         `xml:"recon,omitempty"`
}

AccountPrivileges represents a account privileges.

func (AccountPrivileges) MarshalXML 

func (t AccountPrivileges) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountPrivileges root element name to the wire value declared by the spec (<privileges>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountPrivilegesCasperAdmin 

type AccountPrivilegesCasperAdmin struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

AccountPrivilegesCasperAdmin represents a account privileges casper admin.

func (AccountPrivilegesCasperAdmin) MarshalXML 

func (t AccountPrivilegesCasperAdmin) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountPrivilegesCasperAdmin root element name to the wire value declared by the spec (<casper_admin>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountPrivilegesCasperImaging 

type AccountPrivilegesCasperImaging struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

AccountPrivilegesCasperImaging represents a account privileges casper imaging.

func (AccountPrivilegesCasperImaging) MarshalXML 

func (t AccountPrivilegesCasperImaging) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountPrivilegesCasperImaging root element name to the wire value declared by the spec (<casper_imaging>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountPrivilegesCasperRemote 

type AccountPrivilegesCasperRemote struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

AccountPrivilegesCasperRemote represents a account privileges casper remote.

func (AccountPrivilegesCasperRemote) MarshalXML 

func (t AccountPrivilegesCasperRemote) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountPrivilegesCasperRemote root element name to the wire value declared by the spec (<casper_remote>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountPrivilegesJssActions 

type AccountPrivilegesJssActions struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

AccountPrivilegesJssActions represents a account privileges jss actions.

func (AccountPrivilegesJssActions) MarshalXML 

func (t AccountPrivilegesJssActions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountPrivilegesJssActions root element name to the wire value declared by the spec (<jss_actions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountPrivilegesJssObjects 

type AccountPrivilegesJssObjects struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

AccountPrivilegesJssObjects represents a account privileges jss objects.

func (AccountPrivilegesJssObjects) MarshalXML 

func (t AccountPrivilegesJssObjects) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountPrivilegesJssObjects root element name to the wire value declared by the spec (<jss_objects>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountPrivilegesJssSettings 

type AccountPrivilegesJssSettings struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

AccountPrivilegesJssSettings represents a account privileges jss settings.

func (AccountPrivilegesJssSettings) MarshalXML 

func (t AccountPrivilegesJssSettings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountPrivilegesJssSettings root element name to the wire value declared by the spec (<jss_settings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountPrivilegesRecon 

type AccountPrivilegesRecon struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

AccountPrivilegesRecon represents a account privileges recon.

func (AccountPrivilegesRecon) MarshalXML 

func (t AccountPrivilegesRecon) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountPrivilegesRecon root element name to the wire value declared by the spec (<recon>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Accounts 

type Accounts struct {
	XMLName xml.Name
	ID      *int            `xml:"id,omitempty"`
	Groups  *AccountsGroups `xml:"groups,omitempty"`
	Users   *AccountsUsers  `xml:"users,omitempty"`
}

Accounts represents a accounts.

func (Accounts) MarshalXML 

func (t Accounts) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Accounts root element name to the wire value declared by the spec (<accounts>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountsGroups 

type AccountsGroups struct {
	XMLName xml.Name
	Group   *[]AccountsGroupsGroupItem `xml:"group,omitempty"`
}

AccountsGroups represents a accounts groups.

func (AccountsGroups) MarshalXML 

func (t AccountsGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountsGroups root element name to the wire value declared by the spec (<groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountsGroupsGroupItem 

type AccountsGroupsGroupItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the group.
	Name *string `xml:"name,omitempty"`
}

AccountsGroupsGroupItem represents a accounts groups group item.

func (AccountsGroupsGroupItem) MarshalXML 

func (t AccountsGroupsGroupItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountsGroupsGroupItem root element name to the wire value declared by the spec (<group>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountsUsers 

type AccountsUsers struct {
	XMLName xml.Name
	User    *[]AccountsUsersUserItem `xml:"user,omitempty"`
}

AccountsUsers represents a accounts users.

func (AccountsUsers) MarshalXML 

func (t AccountsUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountsUsers root element name to the wire value declared by the spec (<users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AccountsUsersUserItem 

type AccountsUsersUserItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the account.
	Name *string `xml:"name,omitempty"`
}

AccountsUsersUserItem represents a accounts users user item.

func (AccountsUsersUserItem) MarshalXML 

func (t AccountsUsersUserItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AccountsUsersUserItem root element name to the wire value declared by the spec (<user>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ActivationCode 

type ActivationCode struct {
	XMLName          xml.Name
	Code             *string `xml:"code,omitempty"`
	OrganizationName *string `xml:"organization_name,omitempty"`
}

ActivationCode represents a activation code.

func (ActivationCode) MarshalXML 

func (t ActivationCode) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ActivationCode root element name to the wire value declared by the spec (<activation_code>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedComputerSearch 

type AdvancedComputerSearch struct {
	XMLName       xml.Name
	Computers     *AdvancedComputerSearchComputers     `xml:"computers,omitempty"`
	Criteria      *AdvancedComputerSearchCriteria      `xml:"criteria,omitempty"`
	DisplayFields *AdvancedComputerSearchDisplayFields `xml:"display_fields,omitempty"`
	ID            *int                                 `xml:"id,omitempty"`
	// Name of the advanced computer search.
	Name   *string     `xml:"name,omitempty"`
	Site   *SiteObject `xml:"site,omitempty"`
	Sort1  *string     `xml:"sort_1,omitempty"`
	Sort2  *string     `xml:"sort_2,omitempty"`
	Sort3  *string     `xml:"sort_3,omitempty"`
	ViewAs *string     `xml:"view_as,omitempty"`
}

AdvancedComputerSearch represents a advanced computer search.

func (AdvancedComputerSearch) MarshalXML 

func (t AdvancedComputerSearch) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedComputerSearch root element name to the wire value declared by the spec (<advanced_computer_search>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedComputerSearchComputers 

type AdvancedComputerSearchComputers struct {
	XMLName  xml.Name
	Computer *[]AdvancedComputerSearchComputersComputerItem `xml:"computer,omitempty"`
	Size     *Size                                          `xml:"size,omitempty"`
}

AdvancedComputerSearchComputers represents a advanced computer search computers.

func (AdvancedComputerSearchComputers) MarshalXML 

func (t AdvancedComputerSearchComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedComputerSearchComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedComputerSearchComputersComputerItem 

type AdvancedComputerSearchComputersComputerItem struct {
	XMLName      xml.Name
	ComputerName *string `xml:"Computer_Name,omitempty"`
	ID           *int    `xml:"id,omitempty"`
	// Name of the computer.
	Name *string `xml:"name,omitempty"`
	UDID *string `xml:"udid,omitempty"`
}

AdvancedComputerSearchComputersComputerItem represents a advanced computer search computers computer item.

func (AdvancedComputerSearchComputersComputerItem) MarshalXML 

func (t AdvancedComputerSearchComputersComputerItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedComputerSearchComputersComputerItem root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedComputerSearchCriteria 

type AdvancedComputerSearchCriteria struct {
	XMLName   xml.Name
	Criterion *[]Criterion `xml:"criterion,omitempty"`
	Size      *Size        `xml:"size,omitempty"`
}

AdvancedComputerSearchCriteria represents a advanced computer search criteria.

func (AdvancedComputerSearchCriteria) MarshalXML 

func (t AdvancedComputerSearchCriteria) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedComputerSearchCriteria root element name to the wire value declared by the spec (<criteria>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedComputerSearchDisplayFields 

type AdvancedComputerSearchDisplayFields struct {
	XMLName      xml.Name
	DisplayField *[]AdvancedComputerSearchDisplayFieldsDisplayFieldItem `xml:"display_field,omitempty"`
	Size         *Size                                                  `xml:"size,omitempty"`
}

AdvancedComputerSearchDisplayFields represents a advanced computer search display fields.

func (AdvancedComputerSearchDisplayFields) MarshalXML 

func (t AdvancedComputerSearchDisplayFields) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedComputerSearchDisplayFields root element name to the wire value declared by the spec (<display_fields>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedComputerSearchDisplayFieldsDisplayFieldItem 

type AdvancedComputerSearchDisplayFieldsDisplayFieldItem struct {
	XMLName xml.Name
	// Name of the display field.
	Name *string `xml:"name,omitempty"`
}

AdvancedComputerSearchDisplayFieldsDisplayFieldItem represents a advanced computer search display fields display field item.

func (AdvancedComputerSearchDisplayFieldsDisplayFieldItem) MarshalXML 

func (t AdvancedComputerSearchDisplayFieldsDisplayFieldItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedComputerSearchDisplayFieldsDisplayFieldItem root element name to the wire value declared by the spec (<display_field>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedComputerSearches 

type AdvancedComputerSearches struct {
	XMLName                  xml.Name
	Size                     *Size    `xml:"size,omitempty"`
	AdvancedComputerSearches []IDName `xml:"advanced_computer_search"`
}

AdvancedComputerSearches wraps a Jamf Classic list response with a flat slice of IDName.

func (AdvancedComputerSearches) MarshalXML 

func (t AdvancedComputerSearches) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedComputerSearches root element name to the wire value declared by the spec (<advanced_computer_searches>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedComputerSearchesItem 

type AdvancedComputerSearchesItem struct {
	XMLName                xml.Name
	ID                     *int    `xml:"id,omitempty"`
	AdvancedComputerSearch *IDName `xml:"advanced_computer_search,omitempty"`
	Size                   *Size   `xml:"size,omitempty"`
}

AdvancedComputerSearchesItem represents a advanced computer searches item.

func (AdvancedComputerSearchesItem) MarshalXML 

func (t AdvancedComputerSearchesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedComputerSearchesItem root element name to the wire value declared by the spec (<advanced_computer_searche>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedMobileDeviceSearch 

type AdvancedMobileDeviceSearch struct {
	XMLName       xml.Name
	Criteria      *AdvancedMobileDeviceSearchCriteria      `xml:"criteria,omitempty"`
	DisplayFields *AdvancedMobileDeviceSearchDisplayFields `xml:"display_fields,omitempty"`
	ID            *int                                     `xml:"id,omitempty"`
	MobileDevices *AdvancedMobileDeviceSearchMobileDevices `xml:"mobile_devices,omitempty"`
	// Name of the advanced mobile device search.
	Name   *string     `xml:"name,omitempty"`
	Site   *SiteObject `xml:"site,omitempty"`
	Sort1  *string     `xml:"sort_1,omitempty"`
	Sort2  *string     `xml:"sort_2,omitempty"`
	Sort3  *string     `xml:"sort_3,omitempty"`
	ViewAs *string     `xml:"view_as,omitempty"`
}

AdvancedMobileDeviceSearch represents a advanced mobile device search.

func (AdvancedMobileDeviceSearch) MarshalXML 

func (t AdvancedMobileDeviceSearch) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedMobileDeviceSearch root element name to the wire value declared by the spec (<advanced_mobile_device_search>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedMobileDeviceSearchCriteria 

type AdvancedMobileDeviceSearchCriteria struct {
	XMLName   xml.Name
	Criterion *[]Criterion `xml:"criterion,omitempty"`
	Size      *Size        `xml:"size,omitempty"`
}

AdvancedMobileDeviceSearchCriteria represents a advanced mobile device search criteria.

func (AdvancedMobileDeviceSearchCriteria) MarshalXML 

func (t AdvancedMobileDeviceSearchCriteria) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedMobileDeviceSearchCriteria root element name to the wire value declared by the spec (<criteria>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedMobileDeviceSearchDisplayFields 

type AdvancedMobileDeviceSearchDisplayFields struct {
	XMLName      xml.Name
	DisplayField *[]AdvancedMobileDeviceSearchDisplayFieldsDisplayFieldItem `xml:"display_field,omitempty"`
	Size         *Size                                                      `xml:"size,omitempty"`
}

AdvancedMobileDeviceSearchDisplayFields represents a advanced mobile device search display fields.

func (AdvancedMobileDeviceSearchDisplayFields) MarshalXML 

func (t AdvancedMobileDeviceSearchDisplayFields) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedMobileDeviceSearchDisplayFields root element name to the wire value declared by the spec (<display_fields>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedMobileDeviceSearchDisplayFieldsDisplayFieldItem 

type AdvancedMobileDeviceSearchDisplayFieldsDisplayFieldItem struct {
	XMLName xml.Name
	// Name of the display field.
	Name *string `xml:"name,omitempty"`
}

AdvancedMobileDeviceSearchDisplayFieldsDisplayFieldItem represents a advanced mobile device search display fields display field item.

func (AdvancedMobileDeviceSearchDisplayFieldsDisplayFieldItem) MarshalXML 

func (t AdvancedMobileDeviceSearchDisplayFieldsDisplayFieldItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedMobileDeviceSearchDisplayFieldsDisplayFieldItem root element name to the wire value declared by the spec (<display_field>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedMobileDeviceSearchMobileDevices 

type AdvancedMobileDeviceSearchMobileDevices struct {
	XMLName      xml.Name
	MobileDevice *[]AdvancedMobileDeviceSearchMobileDevicesMobileDeviceItem `xml:"mobile_device,omitempty"`
	Size         *Size                                                      `xml:"size,omitempty"`
}

AdvancedMobileDeviceSearchMobileDevices represents a advanced mobile device search mobile devices.

func (AdvancedMobileDeviceSearchMobileDevices) MarshalXML 

func (t AdvancedMobileDeviceSearchMobileDevices) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedMobileDeviceSearchMobileDevices root element name to the wire value declared by the spec (<mobile_devices>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedMobileDeviceSearchMobileDevicesMobileDeviceItem 

type AdvancedMobileDeviceSearchMobileDevicesMobileDeviceItem struct {
	XMLName     xml.Name
	DisplayName *string `xml:"Display_Name,omitempty"`
	ID          *int    `xml:"id,omitempty"`
	// Name of the mobile device.
	Name *string `xml:"name,omitempty"`
	UDID *string `xml:"udid,omitempty"`
}

AdvancedMobileDeviceSearchMobileDevicesMobileDeviceItem represents a advanced mobile device search mobile devices mobile device item.

func (AdvancedMobileDeviceSearchMobileDevicesMobileDeviceItem) MarshalXML 

func (t AdvancedMobileDeviceSearchMobileDevicesMobileDeviceItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedMobileDeviceSearchMobileDevicesMobileDeviceItem root element name to the wire value declared by the spec (<mobile_device>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedMobileDeviceSearches 

type AdvancedMobileDeviceSearches struct {
	XMLName                      xml.Name
	Size                         *Size    `xml:"size,omitempty"`
	AdvancedMobileDeviceSearches []IDName `xml:"advanced_mobile_device_search"`
}

AdvancedMobileDeviceSearches wraps a Jamf Classic list response with a flat slice of IDName.

func (AdvancedMobileDeviceSearches) MarshalXML 

func (t AdvancedMobileDeviceSearches) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedMobileDeviceSearches root element name to the wire value declared by the spec (<advanced_mobile_device_searches>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedMobileDeviceSearchesItem 

type AdvancedMobileDeviceSearchesItem struct {
	XMLName                    xml.Name
	ID                         *int    `xml:"id,omitempty"`
	AdvancedMobileDeviceSearch *IDName `xml:"advanced_mobile_device_search,omitempty"`
	Size                       *Size   `xml:"size,omitempty"`
}

AdvancedMobileDeviceSearchesItem represents a advanced mobile device searches item.

func (AdvancedMobileDeviceSearchesItem) MarshalXML 

func (t AdvancedMobileDeviceSearchesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedMobileDeviceSearchesItem root element name to the wire value declared by the spec (<advanced_mobile_device_searche>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedUserSearch 

type AdvancedUserSearch struct {
	XMLName       xml.Name
	Criteria      *AdvancedUserSearchCriteria      `xml:"criteria,omitempty"`
	DisplayFields *AdvancedUserSearchDisplayFields `xml:"display_fields,omitempty"`
	ID            *int                             `xml:"id,omitempty"`
	// Name of the advanced user search.
	Name  *string                  `xml:"name,omitempty"`
	Site  *SiteObject              `xml:"site,omitempty"`
	Users *AdvancedUserSearchUsers `xml:"users,omitempty"`
}

AdvancedUserSearch represents a advanced user search.

func (AdvancedUserSearch) MarshalXML 

func (t AdvancedUserSearch) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedUserSearch root element name to the wire value declared by the spec (<advanced_user_search>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedUserSearchCriteria 

type AdvancedUserSearchCriteria struct {
	XMLName   xml.Name
	Criterion *[]Criterion `xml:"criterion,omitempty"`
	Size      *Size        `xml:"size,omitempty"`
}

AdvancedUserSearchCriteria represents a advanced user search criteria.

func (AdvancedUserSearchCriteria) MarshalXML 

func (t AdvancedUserSearchCriteria) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedUserSearchCriteria root element name to the wire value declared by the spec (<criteria>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedUserSearchDisplayFields 

type AdvancedUserSearchDisplayFields struct {
	XMLName      xml.Name
	DisplayField *[]AdvancedUserSearchDisplayFieldsDisplayFieldItem `xml:"display_field,omitempty"`
	Size         *Size                                              `xml:"size,omitempty"`
}

AdvancedUserSearchDisplayFields represents a advanced user search display fields.

func (AdvancedUserSearchDisplayFields) MarshalXML 

func (t AdvancedUserSearchDisplayFields) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedUserSearchDisplayFields root element name to the wire value declared by the spec (<display_fields>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedUserSearchDisplayFieldsDisplayFieldItem 

type AdvancedUserSearchDisplayFieldsDisplayFieldItem struct {
	XMLName xml.Name
	// Name of the display field.
	Name *string `xml:"name,omitempty"`
}

AdvancedUserSearchDisplayFieldsDisplayFieldItem represents a advanced user search display fields display field item.

func (AdvancedUserSearchDisplayFieldsDisplayFieldItem) MarshalXML 

func (t AdvancedUserSearchDisplayFieldsDisplayFieldItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedUserSearchDisplayFieldsDisplayFieldItem root element name to the wire value declared by the spec (<display_field>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedUserSearchUsers 

type AdvancedUserSearchUsers struct {
	XMLName xml.Name
	Size    *Size                              `xml:"size,omitempty"`
	User    *[]AdvancedUserSearchUsersUserItem `xml:"user,omitempty"`
}

AdvancedUserSearchUsers represents a advanced user search users.

func (AdvancedUserSearchUsers) MarshalXML 

func (t AdvancedUserSearchUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedUserSearchUsers root element name to the wire value declared by the spec (<users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedUserSearchUsersUserItem 

type AdvancedUserSearchUsersUserItem struct {
	XMLName  xml.Name
	Username *string `xml:"Username,omitempty"`
	ID       *int    `xml:"id,omitempty"`
	// Name of the user.
	Name *string `xml:"name,omitempty"`
}

AdvancedUserSearchUsersUserItem represents a advanced user search users user item.

func (AdvancedUserSearchUsersUserItem) MarshalXML 

func (t AdvancedUserSearchUsersUserItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedUserSearchUsersUserItem root element name to the wire value declared by the spec (<user>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedUserSearches 

type AdvancedUserSearches struct {
	XMLName              xml.Name
	Size                 *Size    `xml:"size,omitempty"`
	AdvancedUserSearches []IDName `xml:"advanced_user_search"`
}

AdvancedUserSearches wraps a Jamf Classic list response with a flat slice of IDName.

func (AdvancedUserSearches) MarshalXML 

func (t AdvancedUserSearches) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedUserSearches root element name to the wire value declared by the spec (<advanced_user_searches>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AdvancedUserSearchesItem 

type AdvancedUserSearchesItem struct {
	XMLName            xml.Name
	ID                 *int    `xml:"id,omitempty"`
	AdvancedUserSearch *IDName `xml:"advanced_user_search,omitempty"`
	Size               *Size   `xml:"size,omitempty"`
}

AdvancedUserSearchesItem represents a advanced user searches item.

func (AdvancedUserSearchesItem) MarshalXML 

func (t AdvancedUserSearchesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AdvancedUserSearchesItem root element name to the wire value declared by the spec (<advanced_user_searche>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AllowedFileExtension 

type AllowedFileExtension struct {
	XMLName xml.Name
	// File extension.
	Extension *string `xml:"extension,omitempty"`
	ID        *int    `xml:"id,omitempty"`
}

AllowedFileExtension represents a allowed file extension.

func (AllowedFileExtension) MarshalXML 

func (t AllowedFileExtension) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AllowedFileExtension root element name to the wire value declared by the spec (<allowed_file_extension>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AllowedFileExtensions 

type AllowedFileExtensions struct {
	XMLName               xml.Name
	Size                  *Size                  `xml:"size,omitempty"`
	AllowedFileExtensions []AllowedFileExtension `xml:"allowed_file_extension"`
}

AllowedFileExtensions wraps a Jamf Classic list response with a flat slice of AllowedFileExtension.

func (AllowedFileExtensions) MarshalXML 

func (t AllowedFileExtensions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AllowedFileExtensions root element name to the wire value declared by the spec (<allowed_file_extensions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type AllowedFileExtensionsItem 

type AllowedFileExtensionsItem struct {
	XMLName              xml.Name
	ID                   *int                  `xml:"id,omitempty"`
	AllowedFileExtension *AllowedFileExtension `xml:"allowed_file_extension,omitempty"`
	Size                 *Size                 `xml:"size,omitempty"`
}

AllowedFileExtensionsItem represents a allowed file extensions item.

func (AllowedFileExtensionsItem) MarshalXML 

func (t AllowedFileExtensionsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the AllowedFileExtensionsItem root element name to the wire value declared by the spec (<allowed_file_extension>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Attachment 

type Attachment struct {
	XMLName  xml.Name
	Filename *string `xml:"filename,omitempty"`
	ID       *int    `xml:"id,omitempty"`
	URI      *string `xml:"uri,omitempty"`
}

Attachment represents a attachment.

func (Attachment) MarshalXML 

func (t Attachment) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Attachment root element name to the wire value declared by the spec (<attachment>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type BigInt 

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

BigInt is an arbitrary-precision integer with XML/JSON codecs. The zero value is usable and equivalent to big.NewInt(0). Targeted by FieldTypeOverrides for Classic fields the spec types as `integer` whose actual wire values exceed int64 — canonically invitation codes and epoch millis beyond year ~2500.

func (*BigInt) Int 

func (b *BigInt) Int() *big.Int

Int returns a pointer to the underlying math/big.Int so callers can do arithmetic without having to export the internal field. Mutations via the returned pointer are reflected in subsequent marshalling.

func (BigInt) MarshalJSON 

func (b BigInt) MarshalJSON() ([]byte, error)

MarshalJSON emits the value as a JSON number (unquoted) so consumers see the same numeric semantics they would for a regular integer.

func (BigInt) MarshalXML 

func (b BigInt) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML emits the decimal string representation as the element's text content.

func (*BigInt) SetString 

func (b *BigInt) SetString(s string) bool

SetString parses a decimal integer and stores it. Returns false if the input isn't a valid base-10 integer.

func (BigInt) String 

func (b BigInt) String() string

String returns the decimal representation, matching the wire form.

func (*BigInt) UnmarshalJSON 

func (b *BigInt) UnmarshalJSON(data []byte) error

UnmarshalJSON accepts either a JSON number (emitted unquoted) or a JSON string containing a decimal integer. Jamf APIs returning JSON responses can use either encoding depending on the renderer.

func (*BigInt) UnmarshalXML 

func (b *BigInt) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

UnmarshalXML reads the element's text value and parses it as a base-10 integer. Empty content or a non-numeric sentinel (Classic occasionally emits "Unlimited" in otherwise-numeric fields) decodes to zero rather than erroring out. Consumers who care about sentinel detection can inspect the raw body via WithLogger.

type Building 

type Building struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the building.
	Name *string `xml:"name,omitempty"`
}

Building represents a building.

func (Building) MarshalXML 

func (t Building) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Building root element name to the wire value declared by the spec (<building>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Buildings 

type Buildings struct {
	XMLName   xml.Name
	Size      *Size      `xml:"size,omitempty"`
	Buildings []Building `xml:"building"`
}

Buildings wraps a Jamf Classic list response with a flat slice of Building.

func (Buildings) MarshalXML 

func (t Buildings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Buildings root element name to the wire value declared by the spec (<buildings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type BuildingsItem 

type BuildingsItem struct {
	XMLName  xml.Name
	ID       *int      `xml:"id,omitempty"`
	Building *Building `xml:"building,omitempty"`
	Size     *Size     `xml:"size,omitempty"`
}

BuildingsItem represents a buildings item.

func (BuildingsItem) MarshalXML 

func (t BuildingsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the BuildingsItem root element name to the wire value declared by the spec (<building>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Categories 

type Categories struct {
	XMLName    xml.Name
	Size       *Size      `xml:"size,omitempty"`
	Categories []Category `xml:"category"`
}

Categories wraps a Jamf Classic list response with a flat slice of Category.

func (Categories) MarshalXML 

func (t Categories) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Categories root element name to the wire value declared by the spec (<categories>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type CategoriesItem 

type CategoriesItem struct {
	XMLName  xml.Name
	ID       *int      `xml:"id,omitempty"`
	Category *Category `xml:"category,omitempty"`
	Size     *Size     `xml:"size,omitempty"`
}

CategoriesItem represents a categories item.

func (CategoriesItem) MarshalXML 

func (t CategoriesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the CategoriesItem root element name to the wire value declared by the spec (<category>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Category 

type Category struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the category.
	Name     *string `xml:"name,omitempty"`
	Priority *int    `xml:"priority,omitempty"`
}

Category represents a category.

func (Category) MarshalXML 

func (t Category) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Category root element name to the wire value declared by the spec (<category>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type CategoryObject 

type CategoryObject struct {
	ID *int `xml:"id,omitempty"`
	// Name of the category.
	Name *string `xml:"name,omitempty"`
}

CategoryObject represents a category object.

type Class 

type Class struct {
	XMLName              xml.Name
	AppleTvs             *ClassAppleTvs             `xml:"apple_tvs,omitempty"`
	Description          *string                    `xml:"description,omitempty"`
	ID                   *int                       `xml:"id,omitempty"`
	MeetingTimes         *ClassMeetingTimes         `xml:"meeting_times,omitempty"`
	MobileDeviceGroup    *IDName                    `xml:"mobile_device_group,omitempty"`
	MobileDeviceGroupIds *ClassMobileDeviceGroupIds `xml:"mobile_device_group_ids,omitempty"`
	MobileDevices        *ClassMobileDevices        `xml:"mobile_devices,omitempty"`
	// Name of the class.
	Name            *string               `xml:"name,omitempty"`
	Site            *SiteObject           `xml:"site,omitempty"`
	Source          *string               `xml:"source,omitempty"`
	StudentGroupIds *ClassStudentGroupIds `xml:"student_group_ids,omitempty"`
	StudentIds      *ClassStudentIds      `xml:"student_ids,omitempty"`
	Students        *ClassStudents        `xml:"students,omitempty"`
	TeacherGroupIds *ClassTeacherGroupIds `xml:"teacher_group_ids,omitempty"`
	TeacherIds      *ClassTeacherIds      `xml:"teacher_ids,omitempty"`
	Teachers        *ClassTeachers        `xml:"teachers,omitempty"`
}

Class represents a class.

func (Class) MarshalXML 

func (t Class) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Class root element name to the wire value declared by the spec (<class>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassAppleTvs 

type ClassAppleTvs struct {
	XMLName xml.Name
	AppleTv *[]ClassAppleTvsAppleTvItem `xml:"apple_tv,omitempty"`
}

ClassAppleTvs represents a class apple tvs.

func (ClassAppleTvs) MarshalXML 

func (t ClassAppleTvs) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassAppleTvs root element name to the wire value declared by the spec (<apple_tvs>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassAppleTvsAppleTvItem 

type ClassAppleTvsAppleTvItem struct {
	XMLName         xml.Name
	AirplayPassword *string `xml:"airplay_password,omitempty"`
	DeviceID        *string `xml:"device_id,omitempty"`
	Name            *string `xml:"name,omitempty"`
	UDID            *string `xml:"udid,omitempty"`
	WifiMacAddress  *string `xml:"wifi_mac_address,omitempty"`
}

ClassAppleTvsAppleTvItem represents a class apple tvs apple tv item.

func (ClassAppleTvsAppleTvItem) MarshalXML 

func (t ClassAppleTvsAppleTvItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassAppleTvsAppleTvItem root element name to the wire value declared by the spec (<apple_tv>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassMeetingTimes 

type ClassMeetingTimes struct {
	XMLName     xml.Name
	ID          *int                          `xml:"id,omitempty"`
	MeetingTime *ClassMeetingTimesMeetingTime `xml:"meeting_time,omitempty"`
}

ClassMeetingTimes represents a class meeting times.

func (ClassMeetingTimes) MarshalXML 

func (t ClassMeetingTimes) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassMeetingTimes root element name to the wire value declared by the spec (<meeting_times>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassMeetingTimesMeetingTime 

type ClassMeetingTimesMeetingTime struct {
	XMLName xml.Name
	// Allowed values: see the ClassMeetingTimesMeetingTimeDays constants.
	Days      *string `xml:"days,omitempty"`
	EndTime   *int    `xml:"end_time,omitempty"`
	StartTime *int    `xml:"start_time,omitempty"`
}

ClassMeetingTimesMeetingTime represents a class meeting times meeting time.

func (ClassMeetingTimesMeetingTime) MarshalXML 

func (t ClassMeetingTimesMeetingTime) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassMeetingTimesMeetingTime root element name to the wire value declared by the spec (<meeting_time>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassMeetingTimesMeetingTimeDays 

type ClassMeetingTimesMeetingTimeDays = string

ClassMeetingTimesMeetingTimeDays is the set of values accepted by ClassMeetingTimesMeetingTime.Days. 

const (
	ClassMeetingTimesMeetingTimeDaysM  ClassMeetingTimesMeetingTimeDays = "M"
	ClassMeetingTimesMeetingTimeDaysT  ClassMeetingTimesMeetingTimeDays = "T"
	ClassMeetingTimesMeetingTimeDaysW  ClassMeetingTimesMeetingTimeDays = "W"
	ClassMeetingTimesMeetingTimeDaysTh ClassMeetingTimesMeetingTimeDays = "Th"
	ClassMeetingTimesMeetingTimeDaysF  ClassMeetingTimesMeetingTimeDays = "F"
	ClassMeetingTimesMeetingTimeDaysSa ClassMeetingTimesMeetingTimeDays = "Sa"
	ClassMeetingTimesMeetingTimeDaysSu ClassMeetingTimesMeetingTimeDays = "Su"
)

ClassMeetingTimesMeetingTimeDays 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 ClassMeetingTimesMeetingTimeDaysValues 

func ClassMeetingTimesMeetingTimeDaysValues() []ClassMeetingTimesMeetingTimeDays

ClassMeetingTimesMeetingTimeDaysValues returns every value the Jamf API accepts for ClassMeetingTimesMeetingTimeDays, 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 ClassMobileDeviceGroupIds 

type ClassMobileDeviceGroupIds struct {
	XMLName xml.Name
	ID      *[]int `xml:"id,omitempty"`
}

ClassMobileDeviceGroupIds represents a class mobile device group ids.

func (ClassMobileDeviceGroupIds) MarshalXML 

func (t ClassMobileDeviceGroupIds) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassMobileDeviceGroupIds root element name to the wire value declared by the spec (<mobile_device_group_ids>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassMobileDevices 

type ClassMobileDevices struct {
	XMLName      xml.Name
	MobileDevice *[]ClassMobileDevicesMobileDeviceItem `xml:"mobile_device,omitempty"`
}

ClassMobileDevices represents a class mobile devices.

func (ClassMobileDevices) MarshalXML 

func (t ClassMobileDevices) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassMobileDevices root element name to the wire value declared by the spec (<mobile_devices>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassMobileDevicesMobileDeviceItem 

type ClassMobileDevicesMobileDeviceItem struct {
	XMLName xml.Name
	// Name of the device.
	Name           *string `xml:"name,omitempty"`
	UDID           *string `xml:"udid,omitempty"`
	WifiMacAddress *string `xml:"wifi_mac_address,omitempty"`
}

ClassMobileDevicesMobileDeviceItem represents a class mobile devices mobile device item.

func (ClassMobileDevicesMobileDeviceItem) MarshalXML 

func (t ClassMobileDevicesMobileDeviceItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassMobileDevicesMobileDeviceItem root element name to the wire value declared by the spec (<mobile_device>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassPost 

type ClassPost struct {
	XMLName              xml.Name
	AppleTvs             *ClassPostAppleTvs             `xml:"apple_tvs,omitempty"`
	Description          *string                        `xml:"description,omitempty"`
	ID                   *int                           `xml:"id,omitempty"`
	MeetingTimes         *ClassPostMeetingTimes         `xml:"meeting_times,omitempty"`
	MobileDeviceGroup    *IDName                        `xml:"mobile_device_group,omitempty"`
	MobileDeviceGroupIds *ClassPostMobileDeviceGroupIds `xml:"mobile_device_group_ids,omitempty"`
	MobileDevices        *ClassPostMobileDevices        `xml:"mobile_devices,omitempty"`
	// Name of the class.
	Name            *string                   `xml:"name,omitempty"`
	Site            *SiteObject               `xml:"site,omitempty"`
	Source          *string                   `xml:"source,omitempty"`
	StudentGroupIds *ClassPostStudentGroupIds `xml:"student_group_ids,omitempty"`
	StudentIds      *ClassPostStudentIds      `xml:"student_ids,omitempty"`
	Students        *ClassPostStudents        `xml:"students,omitempty"`
	TeacherGroupIds *ClassPostTeacherGroupIds `xml:"teacher_group_ids,omitempty"`
	TeacherIds      *ClassPostTeacherIds      `xml:"teacher_ids,omitempty"`
	Teachers        *ClassPostTeachers        `xml:"teachers,omitempty"`
}

ClassPost represents a class post.

func (ClassPost) MarshalXML 

func (t ClassPost) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassPost root element name to the wire value declared by the spec (<class>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassPostAppleTvs 

type ClassPostAppleTvs struct {
	XMLName xml.Name
	AppleTv *[]ClassPostAppleTvsAppleTvItem `xml:"apple_tv,omitempty"`
}

ClassPostAppleTvs represents a class post apple tvs.

func (ClassPostAppleTvs) MarshalXML 

func (t ClassPostAppleTvs) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassPostAppleTvs root element name to the wire value declared by the spec (<apple_tvs>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassPostAppleTvsAppleTvItem 

type ClassPostAppleTvsAppleTvItem struct {
	XMLName         xml.Name
	AirplayPassword *string `xml:"airplay_password,omitempty"`
	DeviceID        *string `xml:"device_id,omitempty"`
	Name            *string `xml:"name,omitempty"`
	UDID            *string `xml:"udid,omitempty"`
	WifiMacAddress  *string `xml:"wifi_mac_address,omitempty"`
}

ClassPostAppleTvsAppleTvItem represents a class post apple tvs apple tv item.

func (ClassPostAppleTvsAppleTvItem) MarshalXML 

func (t ClassPostAppleTvsAppleTvItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassPostAppleTvsAppleTvItem root element name to the wire value declared by the spec (<apple_tv>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassPostMeetingTimes 

type ClassPostMeetingTimes struct {
	XMLName     xml.Name
	ID          *int                          `xml:"id,omitempty"`
	MeetingTime *ClassMeetingTimesMeetingTime `xml:"meeting_time,omitempty"`
}

ClassPostMeetingTimes represents a class post meeting times.

func (ClassPostMeetingTimes) MarshalXML 

func (t ClassPostMeetingTimes) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassPostMeetingTimes root element name to the wire value declared by the spec (<meeting_times>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassPostMobileDeviceGroupIds 

type ClassPostMobileDeviceGroupIds struct {
	XMLName xml.Name
	ID      *[]int `xml:"id,omitempty"`
}

ClassPostMobileDeviceGroupIds represents a class post mobile device group ids.

func (ClassPostMobileDeviceGroupIds) MarshalXML 

func (t ClassPostMobileDeviceGroupIds) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassPostMobileDeviceGroupIds root element name to the wire value declared by the spec (<mobile_device_group_ids>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassPostMobileDevices 

type ClassPostMobileDevices struct {
	XMLName      xml.Name
	MobileDevice *[]ClassPostMobileDevicesMobileDeviceItem `xml:"mobile_device,omitempty"`
}

ClassPostMobileDevices represents a class post mobile devices.

func (ClassPostMobileDevices) MarshalXML 

func (t ClassPostMobileDevices) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassPostMobileDevices root element name to the wire value declared by the spec (<mobile_devices>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassPostMobileDevicesMobileDeviceItem 

type ClassPostMobileDevicesMobileDeviceItem struct {
	XMLName xml.Name
	// Name of the device.
	Name           *string `xml:"name,omitempty"`
	UDID           *string `xml:"udid,omitempty"`
	WifiMacAddress *string `xml:"wifi_mac_address,omitempty"`
}

ClassPostMobileDevicesMobileDeviceItem represents a class post mobile devices mobile device item.

func (ClassPostMobileDevicesMobileDeviceItem) MarshalXML 

func (t ClassPostMobileDevicesMobileDeviceItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassPostMobileDevicesMobileDeviceItem root element name to the wire value declared by the spec (<mobile_device>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassPostStudentGroupIds 

type ClassPostStudentGroupIds struct {
	XMLName xml.Name
	ID      *[]int `xml:"id,omitempty"`
}

ClassPostStudentGroupIds represents a class post student group ids.

func (ClassPostStudentGroupIds) MarshalXML 

func (t ClassPostStudentGroupIds) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassPostStudentGroupIds root element name to the wire value declared by the spec (<student_group_ids>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassPostStudentIds 

type ClassPostStudentIds struct {
	XMLName xml.Name
	ID      *[]int `xml:"id,omitempty"`
}

ClassPostStudentIds represents a class post student ids.

func (ClassPostStudentIds) MarshalXML 

func (t ClassPostStudentIds) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassPostStudentIds root element name to the wire value declared by the spec (<student_ids>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassPostStudents 

type ClassPostStudents struct {
	XMLName xml.Name
	Student *[]string `xml:"student,omitempty"`
}

ClassPostStudents represents a class post students.

func (ClassPostStudents) MarshalXML 

func (t ClassPostStudents) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassPostStudents root element name to the wire value declared by the spec (<students>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassPostTeacherGroupIds 

type ClassPostTeacherGroupIds struct {
	XMLName xml.Name
	ID      *[]int `xml:"id,omitempty"`
}

ClassPostTeacherGroupIds represents a class post teacher group ids.

func (ClassPostTeacherGroupIds) MarshalXML 

func (t ClassPostTeacherGroupIds) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassPostTeacherGroupIds root element name to the wire value declared by the spec (<teacher_group_ids>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassPostTeacherIds 

type ClassPostTeacherIds struct {
	XMLName xml.Name
	ID      *[]int `xml:"id,omitempty"`
}

ClassPostTeacherIds represents a class post teacher ids.

func (ClassPostTeacherIds) MarshalXML 

func (t ClassPostTeacherIds) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassPostTeacherIds root element name to the wire value declared by the spec (<teacher_ids>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassPostTeachers 

type ClassPostTeachers struct {
	XMLName xml.Name
	Teacher *[]string `xml:"teacher,omitempty"`
}

ClassPostTeachers represents a class post teachers.

func (ClassPostTeachers) MarshalXML 

func (t ClassPostTeachers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassPostTeachers root element name to the wire value declared by the spec (<teachers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassStudentGroupIds 

type ClassStudentGroupIds struct {
	XMLName xml.Name
	ID      *[]int `xml:"id,omitempty"`
}

ClassStudentGroupIds represents a class student group ids.

func (ClassStudentGroupIds) MarshalXML 

func (t ClassStudentGroupIds) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassStudentGroupIds root element name to the wire value declared by the spec (<student_group_ids>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassStudentIds 

type ClassStudentIds struct {
	XMLName xml.Name
	ID      *[]int `xml:"id,omitempty"`
}

ClassStudentIds represents a class student ids.

func (ClassStudentIds) MarshalXML 

func (t ClassStudentIds) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassStudentIds root element name to the wire value declared by the spec (<student_ids>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassStudents 

type ClassStudents struct {
	XMLName xml.Name
	Student *[]string `xml:"student,omitempty"`
}

ClassStudents represents a class students.

func (ClassStudents) MarshalXML 

func (t ClassStudents) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassStudents root element name to the wire value declared by the spec (<students>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassTeacherGroupIds 

type ClassTeacherGroupIds struct {
	XMLName xml.Name
	ID      *[]int `xml:"id,omitempty"`
}

ClassTeacherGroupIds represents a class teacher group ids.

func (ClassTeacherGroupIds) MarshalXML 

func (t ClassTeacherGroupIds) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassTeacherGroupIds root element name to the wire value declared by the spec (<teacher_group_ids>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassTeacherIds 

type ClassTeacherIds struct {
	XMLName xml.Name
	ID      *[]int `xml:"id,omitempty"`
}

ClassTeacherIds represents a class teacher ids.

func (ClassTeacherIds) MarshalXML 

func (t ClassTeacherIds) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassTeacherIds root element name to the wire value declared by the spec (<teacher_ids>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassTeachers 

type ClassTeachers struct {
	XMLName xml.Name
	Teacher *[]string `xml:"teacher,omitempty"`
}

ClassTeachers represents a class teachers.

func (ClassTeachers) MarshalXML 

func (t ClassTeachers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassTeachers root element name to the wire value declared by the spec (<teachers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Classes 

type Classes struct {
	XMLName xml.Name
	Size    *Size              `xml:"size,omitempty"`
	Classes []ClassesItemClass `xml:"class"`
}

Classes wraps a Jamf Classic list response with a flat slice of ClassesItemClass.

func (Classes) MarshalXML 

func (t Classes) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Classes root element name to the wire value declared by the spec (<classes>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassesItem 

type ClassesItem struct {
	XMLName xml.Name
	ID      *int              `xml:"id,omitempty"`
	Class   *ClassesItemClass `xml:"class,omitempty"`
	Size    *Size             `xml:"size,omitempty"`
}

ClassesItem represents a classes item.

func (ClassesItem) MarshalXML 

func (t ClassesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassesItem root element name to the wire value declared by the spec (<class>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ClassesItemClass 

type ClassesItemClass struct {
	XMLName     xml.Name
	Description *string `xml:"description,omitempty"`
	ID          *int    `xml:"id,omitempty"`
	// Name of the class.
	Name *string `xml:"name,omitempty"`
}

ClassesItemClass represents a classes item class.

func (ClassesItemClass) MarshalXML 

func (t ClassesItemClass) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ClassesItemClass root element name to the wire value declared by the spec (<class>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Client 

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

Client provides typed methods for proclassic operations.

func New 

func New(base *jamfplatform.Client) *Client

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

func (*Client) ApplyAccountGroup 

func (c *Client) ApplyAccountGroup(ctx context.Context, request *Group) (string, bool, error)

ApplyAccountGroup creates or updates a AccountGroup 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) ApplyAdvancedComputerSearch 

func (c *Client) ApplyAdvancedComputerSearch(ctx context.Context, request *AdvancedComputerSearch) (string, bool, error)

ApplyAdvancedComputerSearch creates or updates a AdvancedComputerSearch 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) ApplyAdvancedMobileDeviceSearch 

func (c *Client) ApplyAdvancedMobileDeviceSearch(ctx context.Context, request *AdvancedMobileDeviceSearch) (string, bool, error)

ApplyAdvancedMobileDeviceSearch creates or updates a AdvancedMobileDeviceSearch 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) ApplyAdvancedUserSearch 

func (c *Client) ApplyAdvancedUserSearch(ctx context.Context, request *AdvancedUserSearch) (string, bool, error)

ApplyAdvancedUserSearch creates or updates a AdvancedUserSearch 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) ApplyBuilding 

func (c *Client) ApplyBuilding(ctx context.Context, request *Building) (string, bool, error)

ApplyBuilding creates or updates a Building 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) ApplyCategory 

func (c *Client) ApplyCategory(ctx context.Context, request *Category) (string, bool, error)

ApplyCategory creates or updates a Category 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) ApplyClass 

func (c *Client) ApplyClass(ctx context.Context, request *ClassPost) (string, bool, error)

ApplyClass creates or updates a Class 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) ApplyClassicPackage 

func (c *Client) ApplyClassicPackage(ctx context.Context, request *Package) (string, bool, error)

ApplyClassicPackage creates or updates a ClassicPackage 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) ApplyComputerExtensionAttribute 

func (c *Client) ApplyComputerExtensionAttribute(ctx context.Context, request *ComputerExtensionAttribute) (string, bool, error)

ApplyComputerExtensionAttribute creates or updates a ComputerExtensionAttribute 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) ApplyComputerGroup 

func (c *Client) ApplyComputerGroup(ctx context.Context, request *ComputerGroupPost) (string, bool, error)

ApplyComputerGroup creates or updates a ComputerGroup 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) ApplyDepartment 

func (c *Client) ApplyDepartment(ctx context.Context, request *Department) (string, bool, error)

ApplyDepartment creates or updates a Department 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) ApplyDirectoryBinding 

func (c *Client) ApplyDirectoryBinding(ctx context.Context, request *DirectoryBinding) (string, bool, error)

ApplyDirectoryBinding creates or updates a DirectoryBinding 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) ApplyDiskEncryptionConfiguration 

func (c *Client) ApplyDiskEncryptionConfiguration(ctx context.Context, request *DiskEncryptionConfiguration) (string, bool, error)

ApplyDiskEncryptionConfiguration creates or updates a DiskEncryptionConfiguration 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) ApplyDistributionPoint 

func (c *Client) ApplyDistributionPoint(ctx context.Context, request *DistributionPointPost) (string, bool, error)

ApplyDistributionPoint creates or updates a DistributionPoint 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) ApplyDockItem 

func (c *Client) ApplyDockItem(ctx context.Context, request *DockItem) (string, bool, error)

ApplyDockItem creates or updates a DockItem 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) ApplyEbook 

func (c *Client) ApplyEbook(ctx context.Context, request *EbookPost) (string, bool, error)

ApplyEbook creates or updates a Ebook 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) ApplyIBeacon 

func (c *Client) ApplyIBeacon(ctx context.Context, request *Ibeacon) (string, bool, error)

ApplyIBeacon creates or updates a IBeacon 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) ApplyLDAPServer 

func (c *Client) ApplyLDAPServer(ctx context.Context, request *LdapServerPost) (string, bool, error)

ApplyLDAPServer creates or updates a LDAPServer 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) ApplyLicensedSoftware 

func (c *Client) ApplyLicensedSoftware(ctx context.Context, request *LicensedSoftware) (string, bool, error)

ApplyLicensedSoftware creates or updates a LicensedSoftware 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) ApplyMacApplication 

func (c *Client) ApplyMacApplication(ctx context.Context, request *MacApplication) (string, bool, error)

ApplyMacApplication creates or updates a MacApplication 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) ApplyMobileDeviceApplication 

func (c *Client) ApplyMobileDeviceApplication(ctx context.Context, request *MobileDeviceApplication) (string, bool, error)

ApplyMobileDeviceApplication creates or updates a MobileDeviceApplication 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) ApplyMobileDeviceConfigurationProfile 

func (c *Client) ApplyMobileDeviceConfigurationProfile(ctx context.Context, request *MobileDeviceConfigurationProfile) (string, bool, error)

ApplyMobileDeviceConfigurationProfile creates or updates a MobileDeviceConfigurationProfile 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) ApplyMobileDeviceEnrollmentProfile 

func (c *Client) ApplyMobileDeviceEnrollmentProfile(ctx context.Context, request *MobileDeviceEnrollmentProfilePost) (string, bool, error)

ApplyMobileDeviceEnrollmentProfile creates or updates a MobileDeviceEnrollmentProfile 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) ApplyMobileDeviceExtensionAttribute 

func (c *Client) ApplyMobileDeviceExtensionAttribute(ctx context.Context, request *MobileDeviceExtensionAttribute) (string, bool, error)

ApplyMobileDeviceExtensionAttribute creates or updates a MobileDeviceExtensionAttribute 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) ApplyMobileDeviceGroup 

func (c *Client) ApplyMobileDeviceGroup(ctx context.Context, request *MobileDeviceGroup) (string, bool, error)

ApplyMobileDeviceGroup creates or updates a MobileDeviceGroup 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) ApplyMobileDeviceProvisioningProfile 

func (c *Client) ApplyMobileDeviceProvisioningProfile(ctx context.Context, request *MobileDeviceProvisioningProfile) (string, bool, error)

ApplyMobileDeviceProvisioningProfile creates or updates a MobileDeviceProvisioningProfile 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) ApplyNetworkSegment 

func (c *Client) ApplyNetworkSegment(ctx context.Context, request *NetworkSegmentPost) (string, bool, error)

ApplyNetworkSegment creates or updates a NetworkSegment 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) ApplyOSXConfigurationProfile 

func (c *Client) ApplyOSXConfigurationProfile(ctx context.Context, request *OsXConfigurationProfile) (string, bool, error)

ApplyOSXConfigurationProfile creates or updates a OSXConfigurationProfile 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) ApplyPatchExternalSource 

func (c *Client) ApplyPatchExternalSource(ctx context.Context, request *PatchExternalSource) (string, bool, error)

ApplyPatchExternalSource creates or updates a PatchExternalSource 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) ApplyPolicy 

func (c *Client) ApplyPolicy(ctx context.Context, request *PolicyPost) (string, bool, error)

ApplyPolicy creates or updates a Policy 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) ApplyPrinter 

func (c *Client) ApplyPrinter(ctx context.Context, request *Printer) (string, bool, error)

ApplyPrinter creates or updates a Printer 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) ApplyRemovableMacAddress 

func (c *Client) ApplyRemovableMacAddress(ctx context.Context, request *RemovableMacAddress) (string, bool, error)

ApplyRemovableMacAddress creates or updates a RemovableMacAddress 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) ApplyRestrictedSoftware 

func (c *Client) ApplyRestrictedSoftware(ctx context.Context, request *RestrictedSoftware) (string, bool, error)

ApplyRestrictedSoftware creates or updates a RestrictedSoftware 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) ApplyScript 

func (c *Client) ApplyScript(ctx context.Context, request *Script) (string, bool, error)

ApplyScript creates or updates a Script 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) ApplySite 

func (c *Client) ApplySite(ctx context.Context, request *Site) (string, bool, error)

ApplySite creates or updates a Site 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) ApplySoftwareUpdateServer 

func (c *Client) ApplySoftwareUpdateServer(ctx context.Context, request *SoftwareUpdateServer) (string, bool, error)

ApplySoftwareUpdateServer creates or updates a SoftwareUpdateServer 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) ApplyUser 

func (c *Client) ApplyUser(ctx context.Context, request *UserPost) (string, bool, error)

ApplyUser creates or updates a User 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) ApplyUserExtensionAttribute 

func (c *Client) ApplyUserExtensionAttribute(ctx context.Context, request *UserExtensionAttribute) (string, bool, error)

ApplyUserExtensionAttribute creates or updates a UserExtensionAttribute 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) ApplyUserGroup 

func (c *Client) ApplyUserGroup(ctx context.Context, request *UserGroup) (string, bool, error)

ApplyUserGroup creates or updates a UserGroup 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) ApplyWebhook 

func (c *Client) ApplyWebhook(ctx context.Context, request *Webhook) (string, bool, error)

ApplyWebhook creates or updates a Webhook 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) CreateAccountByUserID 

func (c *Client) CreateAccountByUserID(ctx context.Context, id string, request *Account) (*Account, error)

CreateAccountByUserID creates a new account by ID.

Required privileges: accounts:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateAccountByUsername 

func (c *Client) CreateAccountByUsername(ctx context.Context, name string, request *Account) error

CreateAccountByUsername creates a new account by ID.

Required privileges: accounts:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateAccountGroupByID 

func (c *Client) CreateAccountGroupByID(ctx context.Context, id string, request *Group) (*Group, error)

CreateAccountGroupByID creates a new group by ID.

Required privileges: accounts:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateAccountGroupByName 

func (c *Client) CreateAccountGroupByName(ctx context.Context, name string, request *Group) error

CreateAccountGroupByName creates a new group by ID.

Required privileges: accounts:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateAdvancedComputerSearchByID 

func (c *Client) CreateAdvancedComputerSearchByID(ctx context.Context, id string, request *AdvancedComputerSearch) (*AdvancedComputerSearch, error)

CreateAdvancedComputerSearchByID creates a new advanced computer search.

Required privileges: advanced-device-searches:create.

Parameters:

  • id: ID to filter by.

func (*Client) CreateAdvancedComputerSearchByName 

func (c *Client) CreateAdvancedComputerSearchByName(ctx context.Context, name string, request *AdvancedComputerSearch) error

CreateAdvancedComputerSearchByName creates a new advanced computer search.

Required privileges: advanced-device-searches:create.

Parameters:

  • name: ID to filter by.

func (*Client) CreateAdvancedMobileDeviceSearchByID 

func (c *Client) CreateAdvancedMobileDeviceSearchByID(ctx context.Context, id string, request *AdvancedMobileDeviceSearch) (*AdvancedMobileDeviceSearch, error)

CreateAdvancedMobileDeviceSearchByID creates a new advanced mobile device search.

Required privileges: advanced-device-searches:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateAdvancedMobileDeviceSearchByName 

func (c *Client) CreateAdvancedMobileDeviceSearchByName(ctx context.Context, name string, request *AdvancedMobileDeviceSearch) error

CreateAdvancedMobileDeviceSearchByName creates a new advanced mobile device search.

Required privileges: advanced-device-searches:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateAdvancedUserSearchByID 

func (c *Client) CreateAdvancedUserSearchByID(ctx context.Context, id string, request *AdvancedUserSearch) (*AdvancedUserSearch, error)

CreateAdvancedUserSearchByID creates a new advanced user search by ID.

Required privileges: advanced-user-searches:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateAdvancedUserSearchByName 

func (c *Client) CreateAdvancedUserSearchByName(ctx context.Context, name string, request *AdvancedUserSearch) error

CreateAdvancedUserSearchByName creates a new advanced user search by ID.

Required privileges: advanced-user-searches:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateAllowedFileExtensionByID 

func (c *Client) CreateAllowedFileExtensionByID(ctx context.Context, id string, request *AllowedFileExtension) (*AllowedFileExtension, error)

CreateAllowedFileExtensionByID creates a new allowed file extension value by ID.

Required privileges: allowed-file-extension:create.

Parameters:

  • id: Database ID of the extension.

func (*Client) CreateBuildingByID 

func (c *Client) CreateBuildingByID(ctx context.Context, id string, request *Building) (*Building, error)

CreateBuildingByID creates a new building.

Required privileges: buildings:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateBuildingByName 

func (c *Client) CreateBuildingByName(ctx context.Context, name string, request *Building) error

CreateBuildingByName creates a new building.

Required privileges: buildings:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateCategoryByID 

func (c *Client) CreateCategoryByID(ctx context.Context, id string, request *Category) (*Category, error)

CreateCategoryByID creates a new category by ID.

Required privileges: categories:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateCategoryByName 

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

CreateCategoryByName creates a new category by ID.

Required privileges: categories:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateClassByID 

func (c *Client) CreateClassByID(ctx context.Context, id string, request *ClassPost) (*Class, error)

CreateClassByID creates a new class by ID.

Required privileges: classes:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateClassByName 

func (c *Client) CreateClassByName(ctx context.Context, name string, request *ClassPost) error

CreateClassByName creates a new class by ID.

Required privileges: classes:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateClassicPackageByID 

func (c *Client) CreateClassicPackageByID(ctx context.Context, id string, request *Package) (*Package, error)

CreateClassicPackageByID creates a new package by ID.

Required privileges: packages:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateClassicPackageByName 

func (c *Client) CreateClassicPackageByName(ctx context.Context, name string, request *Package) error

CreateClassicPackageByName creates a new package by ID.

Required privileges: packages:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateComputerByID 

func (c *Client) CreateComputerByID(ctx context.Context, id string, request *ComputerPost) error

CreateComputerByID creates a computer.

Required privileges: devices:create, users:create. All of them are required, not alternatives.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateComputerByMacAddress 

func (c *Client) CreateComputerByMacAddress(ctx context.Context, macaddress string, request *ComputerPost) error

CreateComputerByMacAddress creates a computer.

Required privileges: devices:create, users:create. All of them are required, not alternatives.

Parameters:

  • macaddress: ID value to filter by.

func (*Client) CreateComputerByName 

func (c *Client) CreateComputerByName(ctx context.Context, name string, request *ComputerPost) error

CreateComputerByName creates a computer.

Required privileges: devices:create, users:create. All of them are required, not alternatives.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateComputerBySerialNumber 

func (c *Client) CreateComputerBySerialNumber(ctx context.Context, serialNumber string, request *ComputerPost) error

CreateComputerBySerialNumber creates a computer.

Required privileges: devices:create, users:create. All of them are required, not alternatives.

Parameters:

  • serialNumber: ID value to filter by.

func (*Client) CreateComputerByUDID 

func (c *Client) CreateComputerByUDID(ctx context.Context, udid string, request *ComputerPost) error

CreateComputerByUDID creates a computer.

Required privileges: devices:create, users:create. All of them are required, not alternatives.

Parameters:

  • udid: ID value to filter by.

func (*Client) CreateComputerCommandByCommand 

func (c *Client) CreateComputerCommandByCommand(ctx context.Context, command string, request *ComputerCommandPost) (*ComputerCommand, error)

CreateComputerCommandByCommand creates a new computer command using command name.

Required privileges: destructive-device-actions:execute.

Parameters:

  • command: Allowed values: "EnableRemoteDesktop (macOS 10.14.4 and later)", "DisableRemoteDesktop (macOS 10.14.4 and later)".

func (*Client) CreateComputerExtensionAttributeByID 

func (c *Client) CreateComputerExtensionAttributeByID(ctx context.Context, id string, request *ComputerExtensionAttribute) (*ComputerExtensionAttribute, error)

CreateComputerExtensionAttributeByID creates a new computer extension attribute by ID.

Required privileges: extension-attributes:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateComputerExtensionAttributeByName 

func (c *Client) CreateComputerExtensionAttributeByName(ctx context.Context, name string, request *ComputerExtensionAttribute) error

CreateComputerExtensionAttributeByName creates a new computer extension attribute by ID.

Required privileges: extension-attributes:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateComputerGroupByID 

func (c *Client) CreateComputerGroupByID(ctx context.Context, id string, request *ComputerGroupPost) (*ComputerGroup, error)

CreateComputerGroupByID creates a new computer group by ID.

Required privileges: device-groups:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateComputerGroupByName 

func (c *Client) CreateComputerGroupByName(ctx context.Context, name string, request *ComputerGroupPost) error

CreateComputerGroupByName creates a new computer group by ID.

Required privileges: device-groups:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateComputerInvitationByID 

func (c *Client) CreateComputerInvitationByID(ctx context.Context, id string, request *ComputerInvitation) (*ComputerInvitation, error)

CreateComputerInvitationByID creates a new computer invitation by id.

Required privileges: enrollment-invitations:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateComputerInvitationByInvitation 

func (c *Client) CreateComputerInvitationByInvitation(ctx context.Context, invitation string, request *ComputerInvitation) (*ComputerInvitation, error)

CreateComputerInvitationByInvitation creates a new computer invitation by invitation.

Required privileges: enrollment-invitations:create.

Parameters:

  • invitation: Invitation value to filter by.

func (*Client) CreateComputerInvitationByName 

func (c *Client) CreateComputerInvitationByName(ctx context.Context, name string, request *ComputerInvitation) (*ComputerInvitation, error)

CreateComputerInvitationByName creates a new computer invitation by invitation.

Required privileges: enrollment-invitations:create.

Parameters:

  • name: Invitation value to filter by.

func (*Client) CreateDepartmentByID 

func (c *Client) CreateDepartmentByID(ctx context.Context, id string, request *Department) (*Department, error)

CreateDepartmentByID creates a new department by ID.

Required privileges: departments:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateDepartmentByName 

func (c *Client) CreateDepartmentByName(ctx context.Context, name string, request *Department) error

CreateDepartmentByName creates a new department by ID.

Required privileges: departments:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateDirectoryBindingByID 

func (c *Client) CreateDirectoryBindingByID(ctx context.Context, id string, request *DirectoryBinding) (*DirectoryBinding, error)

CreateDirectoryBindingByID creates a new directory binding by ID.

Required privileges: directory-bindings:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateDirectoryBindingByName 

func (c *Client) CreateDirectoryBindingByName(ctx context.Context, name string, request *DirectoryBinding) error

CreateDirectoryBindingByName creates a new directory binding by ID.

Required privileges: directory-bindings:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateDiskEncryptionConfigurationByID 

func (c *Client) CreateDiskEncryptionConfigurationByID(ctx context.Context, id string, request *DiskEncryptionConfiguration) (*DiskEncryptionConfiguration, error)

CreateDiskEncryptionConfigurationByID creates a new disk encryption configuration by ID.

Required privileges: disk-encryption-configurations:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateDiskEncryptionConfigurationByName 

func (c *Client) CreateDiskEncryptionConfigurationByName(ctx context.Context, name string, request *DiskEncryptionConfiguration) error

CreateDiskEncryptionConfigurationByName creates a new disk encryption configuration by ID.

Required privileges: disk-encryption-configurations:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateDistributionPointByID 

func (c *Client) CreateDistributionPointByID(ctx context.Context, id string, request *DistributionPointPost) (*DistributionPoint, error)

CreateDistributionPointByID creates a new distribution point by ID.

Required privileges: distribution-points:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateDistributionPointByName 

func (c *Client) CreateDistributionPointByName(ctx context.Context, name string, request *DistributionPointPost) error

CreateDistributionPointByName creates a new distribution point by ID.

Required privileges: distribution-points:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateDockItemByID 

func (c *Client) CreateDockItemByID(ctx context.Context, id string, request *DockItem) (*DockItem, error)

CreateDockItemByID creates a new dock item by ID.

Required privileges: dock-items:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateDockItemByName 

func (c *Client) CreateDockItemByName(ctx context.Context, name string, request *DockItem) error

CreateDockItemByName creates a new dock item by ID.

Required privileges: dock-items:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateEbookByID 

func (c *Client) CreateEbookByID(ctx context.Context, id string, request *EbookPost) (*Ebook, error)

CreateEbookByID creates a new ebook by ID.

Required privileges: ebooks:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateEbookByName 

func (c *Client) CreateEbookByName(ctx context.Context, name string, request *EbookPost) error

CreateEbookByName creates a new ebook by ID.

Required privileges: ebooks:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateHealthcareListenerRuleByID 

func (c *Client) CreateHealthcareListenerRuleByID(ctx context.Context, id string, request *HealthcareListenerRule) (*HealthcareListenerRule, error)

CreateHealthcareListenerRuleByID creates a new Healthcare Listener rule.

Required privileges: infrastructure-managers:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateIBeaconByID 

func (c *Client) CreateIBeaconByID(ctx context.Context, id string, request *Ibeacon) (*Ibeacon, error)

CreateIBeaconByID creates a new iBeacon region by ID.

Required privileges: ibeacon:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateIBeaconByName 

func (c *Client) CreateIBeaconByName(ctx context.Context, name string, request *Ibeacon) error

CreateIBeaconByName creates a new iBeacon region by ID.

Required privileges: ibeacon:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateJsonWebTokenConfigurationByID 

func (c *Client) CreateJsonWebTokenConfigurationByID(ctx context.Context, id string, request *JsonWebTokenConfiguration) (*JsonWebTokenConfiguration, error)

CreateJsonWebTokenConfigurationByID creates a new JSON Web Token configuration by ID.

Required privileges: json-web-token-configuration:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateLDAPServerByID 

func (c *Client) CreateLDAPServerByID(ctx context.Context, id string, request *LdapServerPost) (*LdapServer, error)

CreateLDAPServerByID creates a new LDAP server by ID.

Required privileges: ldap-servers:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateLDAPServerByName 

func (c *Client) CreateLDAPServerByName(ctx context.Context, name string, request *LdapServerPost) error

CreateLDAPServerByName creates a new LDAP server by ID.

Required privileges: ldap-servers:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateLicensedSoftwareByID 

func (c *Client) CreateLicensedSoftwareByID(ctx context.Context, id string, request *LicensedSoftware) (*LicensedSoftware, error)

CreateLicensedSoftwareByID creates new licensed software by ID.

Required privileges: licensed-software:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateLicensedSoftwareByName 

func (c *Client) CreateLicensedSoftwareByName(ctx context.Context, name string, request *LicensedSoftware) error

CreateLicensedSoftwareByName creates new licensed software by ID.

Required privileges: licensed-software:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateMacApplicationByID 

func (c *Client) CreateMacApplicationByID(ctx context.Context, id string, request *MacApplication) (*MacApplication, error)

CreateMacApplicationByID creates a new mac application by ID.

Required privileges: applications:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateMacApplicationByName 

func (c *Client) CreateMacApplicationByName(ctx context.Context, name string, request *MacApplication) error

CreateMacApplicationByName creates a new mac application by ID.

Required privileges: applications:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateMobileDeviceApplicationByID 

func (c *Client) CreateMobileDeviceApplicationByID(ctx context.Context, id string, request *MobileDeviceApplication) (*MobileDeviceApplication, error)

CreateMobileDeviceApplicationByID creates a new mobile device application by ID.

Required privileges: applications:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateMobileDeviceApplicationByName 

func (c *Client) CreateMobileDeviceApplicationByName(ctx context.Context, name string, request *MobileDeviceApplication) error

CreateMobileDeviceApplicationByName creates a new mobile device application by ID.

Required privileges: applications:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateMobileDeviceByID 

func (c *Client) CreateMobileDeviceByID(ctx context.Context, id string, request *MobileDevicePost) (*MobileDevice, error)

CreateMobileDeviceByID creates a new mobile device by ID.

Required privileges: devices:create, users:create. All of them are required, not alternatives.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateMobileDeviceByMacAddress 

func (c *Client) CreateMobileDeviceByMacAddress(ctx context.Context, macaddress string, request *MobileDevicePost) error

CreateMobileDeviceByMacAddress creates a new mobile device by ID.

Required privileges: devices:create, users:create. All of them are required, not alternatives.

Parameters:

  • macaddress: ID value to filter by.

func (*Client) CreateMobileDeviceByName 

func (c *Client) CreateMobileDeviceByName(ctx context.Context, name string, request *MobileDevicePost) error

CreateMobileDeviceByName creates a new mobile device by ID.

Required privileges: devices:create, users:create. All of them are required, not alternatives.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateMobileDeviceBySerialNumber 

func (c *Client) CreateMobileDeviceBySerialNumber(ctx context.Context, serialNumber string, request *MobileDevicePost) error

CreateMobileDeviceBySerialNumber creates a new mobile device by ID.

Required privileges: devices:create, users:create. All of them are required, not alternatives.

Parameters:

  • serialNumber: ID value to filter by.

func (*Client) CreateMobileDeviceByUDID 

func (c *Client) CreateMobileDeviceByUDID(ctx context.Context, udid string, request *MobileDevicePost) error

CreateMobileDeviceByUDID creates a new mobile device by ID.

Required privileges: devices:create, users:create. All of them are required, not alternatives.

Parameters:

  • udid: ID value to filter by.

func (*Client) CreateMobileDeviceCommandByCommand 

func (c *Client) CreateMobileDeviceCommandByCommand(ctx context.Context, command string, request *MobileDeviceCommandPost) error

CreateMobileDeviceCommandByCommand creates a new mobile device command.

Required privileges: destructive-device-actions:execute.

Parameters:

  • command: Command to send device. Allowed values: "DeviceLocation (DeviceLocation Deprecated on 2025-06-12)", "EnableLostMode", "PasscodeLockGracePeriod (PasscodeLockGracePeriod Deprecated on 2025-06-26)", "PlayLostModeSound (PlayLostModeSound Deprecated on 2025-06-12)", "Settings", "UpdateInventory (Deprecated on 2026-03-13)".

func (*Client) CreateMobileDeviceCommandByCommandID 

func (c *Client) CreateMobileDeviceCommandByCommandID(ctx context.Context, command string, id_list string, request *MobileDeviceCommandPost) error

CreateMobileDeviceCommandByCommandID creates a new mobile device command.

Required privileges: destructive-device-actions:execute.

Parameters:

  • command: Command to send device. Allowed values: "DeviceLocation (DeviceLocation Deprecated on 2025-06-12)", "EnableLostMode", "PasscodeLockGracePeriod (PasscodeLockGracePeriod Deprecated on 2025-06-26)", "PlayLostModeSound (PlayLostModeSound Deprecated on 2025-06-12)", "Settings", "UpdateInventory (Deprecated on 2026-03-13)".
  • id_list: Mobile device ID values, multiple IDs may be separated by commas (e.g. /id/13,14,15).

func (*Client) CreateMobileDeviceCommandByName 

func (c *Client) CreateMobileDeviceCommandByName(ctx context.Context, name string, request *MobileDeviceCommandPost) error

CreateMobileDeviceCommandByName creates a new mobile device command.

Required privileges: destructive-device-actions:execute.

Parameters:

  • name: Path parameter name.

func (*Client) CreateMobileDeviceCommandWithParameterByIDList 

func (c *Client) CreateMobileDeviceCommandWithParameterByIDList(ctx context.Context, command string, parameter string, idList string, request *MobileDeviceCommandPost) error

CreateMobileDeviceCommandWithParameterByIDList creates a new mobile device command.

Required privileges: device-actions:execute.

Parameters:

  • command: Command to send device. Allowed values: "DeviceLocation (DeviceLocation Deprecated on 2025-06-12)", "EnableLostMode", "PasscodeLockGracePeriod (PasscodeLockGracePeriod Deprecated on 2025-06-26)", "PlayLostModeSound (PlayLostModeSound Deprecated on 2025-06-12)", "Settings", "UpdateInventory (Deprecated on 2026-03-13)".
  • parameter: Path parameter parameter.
  • idList: Mobile device ID values, multiple IDs may be separated by commas (e.g. /id/13,14,15).

func (*Client) CreateMobileDeviceCommandWithParameterVersionByIDList 

func (c *Client) CreateMobileDeviceCommandWithParameterVersionByIDList(ctx context.Context, command string, parameter string, version string, idList string, request *MobileDeviceCommandPost) error

CreateMobileDeviceCommandWithParameterVersionByIDList creates a new mobile device command.

Required privileges: device-actions:execute.

Parameters:

  • command: Command to send device. Allowed values: "DeviceLocation (DeviceLocation Deprecated on 2025-06-12)", "EnableLostMode", "PasscodeLockGracePeriod (PasscodeLockGracePeriod Deprecated on 2025-06-26)", "PlayLostModeSound (PlayLostModeSound Deprecated on 2025-06-12)", "Settings", "UpdateInventory (Deprecated on 2026-03-13)".
  • parameter: Path parameter parameter.
  • version: Path parameter version.
  • idList: Mobile device ID values, multiple IDs may be separated by commas (e.g. /id/13,14,15).

func (*Client) CreateMobileDeviceConfigurationProfileByID 

func (c *Client) CreateMobileDeviceConfigurationProfileByID(ctx context.Context, id string, request *MobileDeviceConfigurationProfile) (*MobileDeviceConfigurationProfile, error)

CreateMobileDeviceConfigurationProfileByID creates a new mobile device configuration profile by ID.

Required privileges: configuration-profiles:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateMobileDeviceConfigurationProfileByName 

func (c *Client) CreateMobileDeviceConfigurationProfileByName(ctx context.Context, name string, request *MobileDeviceConfigurationProfile) error

CreateMobileDeviceConfigurationProfileByName creates a new mobile device configuration profile by ID.

Required privileges: configuration-profiles:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateMobileDeviceEnrollmentProfileByID 

func (c *Client) CreateMobileDeviceEnrollmentProfileByID(ctx context.Context, id string, request *MobileDeviceEnrollmentProfilePost) (*MobileDeviceEnrollmentProfile, error)

CreateMobileDeviceEnrollmentProfileByID creates a new mobile device enrollment profile by ID.

Required privileges: enrollment-profiles:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateMobileDeviceEnrollmentProfileByInvitation 

func (c *Client) CreateMobileDeviceEnrollmentProfileByInvitation(ctx context.Context, invitation string, request *MobileDeviceEnrollmentProfilePost) error

CreateMobileDeviceEnrollmentProfileByInvitation creates a new mobile device enrollment profile by ID.

Required privileges: enrollment-profiles:create.

Parameters:

  • invitation: ID value to filter by.

func (*Client) CreateMobileDeviceEnrollmentProfileByName 

func (c *Client) CreateMobileDeviceEnrollmentProfileByName(ctx context.Context, name string, request *MobileDeviceEnrollmentProfilePost) error

CreateMobileDeviceEnrollmentProfileByName creates a new mobile device enrollment profile by ID.

Required privileges: enrollment-profiles:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateMobileDeviceExtensionAttributeByID 

func (c *Client) CreateMobileDeviceExtensionAttributeByID(ctx context.Context, id string, request *MobileDeviceExtensionAttribute) (*MobileDeviceExtensionAttribute, error)

CreateMobileDeviceExtensionAttributeByID creates a new mobile device extension attribute by ID.

Required privileges: extension-attributes:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateMobileDeviceExtensionAttributeByName 

func (c *Client) CreateMobileDeviceExtensionAttributeByName(ctx context.Context, name string, request *MobileDeviceExtensionAttribute) error

CreateMobileDeviceExtensionAttributeByName creates a new mobile device extension attribute by ID.

Required privileges: extension-attributes:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateMobileDeviceGroupByID 

func (c *Client) CreateMobileDeviceGroupByID(ctx context.Context, id string, request *MobileDeviceGroup) (*MobileDeviceGroup, error)

CreateMobileDeviceGroupByID creates a new mobile device group by ID.

Required privileges: device-groups:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateMobileDeviceGroupByName 

func (c *Client) CreateMobileDeviceGroupByName(ctx context.Context, name string, request *MobileDeviceGroup) error

CreateMobileDeviceGroupByName creates a new mobile device group by ID.

Required privileges: device-groups:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateMobileDeviceInvitationByID 

func (c *Client) CreateMobileDeviceInvitationByID(ctx context.Context, id string, request *MobileDeviceInvitationPost) (*MobileDeviceInvitation, error)

CreateMobileDeviceInvitationByID creates a new mobile device invitation by id.

Required privileges: enrollment-invitations:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateMobileDeviceInvitationByInvitation 

func (c *Client) CreateMobileDeviceInvitationByInvitation(ctx context.Context, invitation string, request *MobileDeviceInvitationPost) (*MobileDeviceInvitation, error)

CreateMobileDeviceInvitationByInvitation creates a new mobile device invitation by invitation.

Required privileges: enrollment-invitations:create.

Parameters:

  • invitation: Invitation value to filter by.

func (*Client) CreateMobileDeviceProvisioningProfileByID 

func (c *Client) CreateMobileDeviceProvisioningProfileByID(ctx context.Context, id string, request *MobileDeviceProvisioningProfile) (*MobileDeviceProvisioningProfile, error)

CreateMobileDeviceProvisioningProfileByID creates a mobile device provisioning profiles by id.

Required privileges: provisioning-profiles:create.

Parameters:

  • id: Id value to filter by.

func (*Client) CreateMobileDeviceProvisioningProfileByName 

func (c *Client) CreateMobileDeviceProvisioningProfileByName(ctx context.Context, name string, request *MobileDeviceProvisioningProfile) (*MobileDeviceProvisioningProfile, error)

CreateMobileDeviceProvisioningProfileByName creates a mobile device provisioning profiles by name.

Required privileges: provisioning-profiles:create.

Parameters:

  • name: Name value to filter by.

func (*Client) CreateMobileDeviceProvisioningProfileByUUID 

func (c *Client) CreateMobileDeviceProvisioningProfileByUUID(ctx context.Context, uuid string, request *MobileDeviceProvisioningProfile) (*MobileDeviceProvisioningProfile, error)

CreateMobileDeviceProvisioningProfileByUUID creates a mobile device provisioning profiles by uuid.

Required privileges: provisioning-profiles:create.

Parameters:

  • uuid: Uuid value to filter by.

func (*Client) CreateNetworkSegmentByID 

func (c *Client) CreateNetworkSegmentByID(ctx context.Context, id string, request *NetworkSegmentPost) (*NetworkSegment, error)

CreateNetworkSegmentByID creates a new network segment by ID.

Required privileges: network-segments:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateNetworkSegmentByName 

func (c *Client) CreateNetworkSegmentByName(ctx context.Context, name string, request *NetworkSegmentPost) error

CreateNetworkSegmentByName creates a new network segment by ID.

Required privileges: network-segments:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateOSXConfigurationProfileByID 

func (c *Client) CreateOSXConfigurationProfileByID(ctx context.Context, id string, request *OsXConfigurationProfile) (*OsXConfigurationProfile, error)

CreateOSXConfigurationProfileByID creates a new OS X configuration profile by ID.

Required privileges: configuration-profiles:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateOSXConfigurationProfileByName 

func (c *Client) CreateOSXConfigurationProfileByName(ctx context.Context, name string, request *OsXConfigurationProfile) error

CreateOSXConfigurationProfileByName creates a new OS X configuration profile by ID.

Required privileges: configuration-profiles:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreatePatchByID deprecated 

func (c *Client) CreatePatchByID(ctx context.Context, id string, request *SoftwareTitle) (*SoftwareTitle, error)

CreatePatchByID creates a patch software title (Deprecated - Please transition use to Jamf Pro API endpoint "/v2/patch-software-title-configurations".).

Deprecated: this endpoint is marked deprecated in the Jamf API spec and may be removed in a future release.

Required privileges: patch-management-software-titles:create.

func (*Client) CreatePatchExternalSourceByID 

func (c *Client) CreatePatchExternalSourceByID(ctx context.Context, id string, request *PatchExternalSource) (*PatchExternalSource, error)

CreatePatchExternalSourceByID create a new patch external source by ID.

Required privileges: patch-external-source:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreatePatchExternalSourceByName 

func (c *Client) CreatePatchExternalSourceByName(ctx context.Context, name string, request *PatchExternalSource) (*PatchExternalSource, error)

CreatePatchExternalSourceByName create a new patch external source by name.

Required privileges: patch-external-source:create.

Parameters:

  • name: Name to filter by.

func (*Client) CreatePatchPolicyBySoftwareTitleConfigID 

func (c *Client) CreatePatchPolicyBySoftwareTitleConfigID(ctx context.Context, softwareTitleConfigID string, request *PatchPolicy) (*PatchPolicy, error)

CreatePatchPolicyBySoftwareTitleConfigID create a new patch policy associated with a patch software title configuration ID.

Required privileges: patch-policies:create.

Parameters:

  • softwareTitleConfigID: Patch software title config ID value to filter by.

func (*Client) CreatePatchSoftwareTitleByID deprecated 

func (c *Client) CreatePatchSoftwareTitleByID(ctx context.Context, id string, request *PatchSoftwareTitle) (*PatchSoftwareTitle, error)

CreatePatchSoftwareTitleByID creates new patch software title by ID. (Deprecated) Please transition use to Jamf Pro API endpoint "/v2/patch-software-title-configurations/{id}".

Deprecated: this endpoint is marked deprecated in the Jamf API spec and may be removed in a future release.

Required privileges: patch-management-software-titles:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreatePolicyByID 

func (c *Client) CreatePolicyByID(ctx context.Context, id string, request *PolicyPost) (*Policy, error)

CreatePolicyByID creates a new policy by ID.

Required privileges: policies:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreatePolicyByName 

func (c *Client) CreatePolicyByName(ctx context.Context, name string, request *PolicyPost) error

CreatePolicyByName creates a new policy by ID.

Required privileges: policies:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreatePrinterByID 

func (c *Client) CreatePrinterByID(ctx context.Context, id string, request *Printer) (*Printer, error)

CreatePrinterByID creates a new printer by ID.

Required privileges: printers:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreatePrinterByName 

func (c *Client) CreatePrinterByName(ctx context.Context, name string, request *Printer) error

CreatePrinterByName creates a new printer by ID.

Required privileges: printers:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateRemovableMacAddressByID 

func (c *Client) CreateRemovableMacAddressByID(ctx context.Context, id string, request *RemovableMacAddress) (*RemovableMacAddress, error)

CreateRemovableMacAddressByID creates a new removable Mac address by ID.

Required privileges: removable-mac-address:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateRemovableMacAddressByName 

func (c *Client) CreateRemovableMacAddressByName(ctx context.Context, name string, request *RemovableMacAddress) error

CreateRemovableMacAddressByName creates a new removable Mac address by ID.

Required privileges: removable-mac-address:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateRestrictedSoftwareByID 

func (c *Client) CreateRestrictedSoftwareByID(ctx context.Context, id string, request *RestrictedSoftware) (*RestrictedSoftware, error)

CreateRestrictedSoftwareByID creates a new restricted software by ID.

Required privileges: restricted-software:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateRestrictedSoftwareByName 

func (c *Client) CreateRestrictedSoftwareByName(ctx context.Context, name string, request *RestrictedSoftware) error

CreateRestrictedSoftwareByName creates a new restricted software by ID.

Required privileges: restricted-software:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateScriptByID 

func (c *Client) CreateScriptByID(ctx context.Context, id string, request *Script) (*Script, error)

CreateScriptByID creates a new script by ID.

Required privileges: scripts:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateScriptByName 

func (c *Client) CreateScriptByName(ctx context.Context, name string, request *Script) error

CreateScriptByName creates a new script by ID.

Required privileges: scripts:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateSiteByID 

func (c *Client) CreateSiteByID(ctx context.Context, id string, request *Site) (*Site, error)

CreateSiteByID creates a new site by ID.

Required privileges: sites:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateSiteByName 

func (c *Client) CreateSiteByName(ctx context.Context, name string, request *Site) error

CreateSiteByName creates a new site by ID.

Required privileges: sites:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateSoftwareUpdateServerByID 

func (c *Client) CreateSoftwareUpdateServerByID(ctx context.Context, id string, request *SoftwareUpdateServer) (*SoftwareUpdateServer, error)

CreateSoftwareUpdateServerByID creates a new software update server by ID.

Required privileges: software-update-servers:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateSoftwareUpdateServerByName 

func (c *Client) CreateSoftwareUpdateServerByName(ctx context.Context, name string, request *SoftwareUpdateServer) error

CreateSoftwareUpdateServerByName creates a new software update server by ID.

Required privileges: software-update-servers:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateUserByID 

func (c *Client) CreateUserByID(ctx context.Context, id string, request *UserPost) (*User, error)

CreateUserByID creates a new user by ID.

Required privileges: users:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateUserByName 

func (c *Client) CreateUserByName(ctx context.Context, name string, request *UserPost) error

CreateUserByName creates a new user by ID.

Required privileges: users:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateUserExtensionAttributeByID 

func (c *Client) CreateUserExtensionAttributeByID(ctx context.Context, id string, request *UserExtensionAttribute) (*UserExtensionAttribute, error)

CreateUserExtensionAttributeByID creates a new user extension attribute by ID.

Required privileges: user-extension-attributes:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateUserExtensionAttributeByName 

func (c *Client) CreateUserExtensionAttributeByName(ctx context.Context, name string, request *UserExtensionAttribute) error

CreateUserExtensionAttributeByName creates a new user extension attribute by ID.

Required privileges: user-extension-attributes:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateUserGroupByID 

func (c *Client) CreateUserGroupByID(ctx context.Context, id string, request *UserGroup) (*UserGroup, error)

CreateUserGroupByID creates user groups by ID.

Required privileges: user-groups:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateUserGroupByName 

func (c *Client) CreateUserGroupByName(ctx context.Context, name string, request *UserGroup) error

CreateUserGroupByName creates user groups by ID.

Required privileges: user-groups:create.

Parameters:

  • name: ID value to filter by.

func (*Client) CreateVPPAccountByID 

func (c *Client) CreateVPPAccountByID(ctx context.Context, id string, request *VppAccount) (*VppAccount, error)

CreateVPPAccountByID creates a new VPP account by ID.

Required privileges: volume-purchasing-locations:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateVPPAssignmentByID 

func (c *Client) CreateVPPAssignmentByID(ctx context.Context, id string, request *VppAssignmentPost) (*VppAssignment, error)

CreateVPPAssignmentByID creates a new VPP assignment by ID.

Required privileges: volume-purchasing-locations:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateVPPInvitationByID 

func (c *Client) CreateVPPInvitationByID(ctx context.Context, id string, request *VppInvitation) (*VppInvitation, error)

CreateVPPInvitationByID creates a new VPP invitation by ID.

Required privileges: volume-purchasing-locations:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateWebhookByID 

func (c *Client) CreateWebhookByID(ctx context.Context, id string, request *Webhook) (*Webhook, error)

CreateWebhookByID creates a new webhook by ID.

Required privileges: webhooks:create.

Parameters:

  • id: ID value to filter by.

func (*Client) CreateWebhookByName 

func (c *Client) CreateWebhookByName(ctx context.Context, name string, request *Webhook) error

CreateWebhookByName creates a new webhook by ID.

Required privileges: webhooks:create.

Parameters:

  • name: ID value to filter by.

func (*Client) DeleteAccountByUserID 

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

DeleteAccountByUserID deletes an account by ID.

Required privileges: accounts:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteAccountByUsername 

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

DeleteAccountByUsername deletes an account by name.

Required privileges: accounts:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteAccountGroupByID 

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

DeleteAccountGroupByID deletes a group by ID.

Required privileges: accounts:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteAccountGroupByName 

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

DeleteAccountGroupByName deletes a group by name.

Required privileges: accounts:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteAdvancedComputerSearchByID 

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

DeleteAdvancedComputerSearchByID deletes a computer search by ID.

Required privileges: advanced-device-searches:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteAdvancedComputerSearchByName 

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

DeleteAdvancedComputerSearchByName deletes a computer search by name.

Required privileges: advanced-device-searches:delete.

Parameters:

  • name: Name to filter by.

func (*Client) DeleteAdvancedMobileDeviceSearchByID 

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

DeleteAdvancedMobileDeviceSearchByID deletes a mobile device search by ID.

Required privileges: advanced-device-searches:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteAdvancedMobileDeviceSearchByName 

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

DeleteAdvancedMobileDeviceSearchByName deletes a mobile device search by name.

Required privileges: advanced-device-searches:delete.

Parameters:

  • name: Name to filter by.

func (*Client) DeleteAdvancedUserSearchByID 

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

DeleteAdvancedUserSearchByID deletes a user search by ID.

Required privileges: advanced-user-searches:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteAdvancedUserSearchByName 

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

DeleteAdvancedUserSearchByName deletes a user search by Name.

Required privileges: advanced-user-searches:delete.

Parameters:

  • name: Name to filter by.

func (*Client) DeleteAllowedFileExtensionByID 

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

DeleteAllowedFileExtensionByID deletes an allowed file extension value by ID.

Required privileges: allowed-file-extension:delete.

Parameters:

  • id: Database ID of the extension.

func (*Client) DeleteBuildingByID 

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

DeleteBuildingByID deletes a building by ID.

Required privileges: buildings:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteBuildingByName 

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

DeleteBuildingByName deletes a building by name.

Required privileges: buildings:delete.

Parameters:

  • name: Name to filter by.

func (*Client) DeleteCategoryByID 

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

DeleteCategoryByID deletes a category by ID.

Required privileges: categories:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteCategoryByName 

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

DeleteCategoryByName deletes a category by name.

Required privileges: categories:delete.

Parameters:

  • name: Name to filter by.

func (*Client) DeleteClassByID 

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

DeleteClassByID deletes a class by ID.

Required privileges: classes:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteClassByName 

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

DeleteClassByName deletes a class by name.

Required privileges: classes:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteClassicPackageByID 

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

DeleteClassicPackageByID deletes a package by ID.

Required privileges: packages:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteClassicPackageByName 

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

DeleteClassicPackageByName deletes a package by name.

Required privileges: packages:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteCommandFlush 

func (c *Client) DeleteCommandFlush(ctx context.Context, request *Commandflush) error

DeleteCommandFlush flushes commands based on information specified in an XML file.

Required privileges: device-actions:delete.

func (*Client) DeleteCommandFlushByIDTypeIDStatus 

func (c *Client) DeleteCommandFlushByIDTypeIDStatus(ctx context.Context, idtype string, id string, status string) error

DeleteCommandFlushByIDTypeIDStatus flushes commands for devices.

Required privileges: device-actions:delete.

Parameters:

  • idtype: Type of device to be flushed. Allowed values: "computers", "computergroups", "mobiledevices", "mobiledevicegroups".
  • id: ID of device to be flushed.
  • status: Command status to be flushed. Allowed values: "Pending", "Failed", "Pending+Failed".

func (*Client) DeleteComputerByID 

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

DeleteComputerByID deletes a computer by ID.

Required privileges: destructive-device-actions:execute.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteComputerExtensionAttributeByID 

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

DeleteComputerExtensionAttributeByID deletes a computer extension attribute by ID.

Required privileges: extension-attributes:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteComputerExtensionAttributeByName 

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

DeleteComputerExtensionAttributeByName deletes a computer extension attribute by name.

Required privileges: extension-attributes:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteComputerGroupByID 

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

DeleteComputerGroupByID deletes a computer group by ID.

Required privileges: device-groups:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteComputerGroupByName 

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

DeleteComputerGroupByName deletes a computer group by name.

Required privileges: device-groups:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteComputerInvitationByID 

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

DeleteComputerInvitationByID deletes a computer invitation by id.

Required privileges: enrollment-invitations:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteComputerInvitationByInvitation 

func (c *Client) DeleteComputerInvitationByInvitation(ctx context.Context, invitation string) error

DeleteComputerInvitationByInvitation deletes a computer invitation by invitation.

Required privileges: enrollment-invitations:delete.

Parameters:

  • invitation: Invitation value to filter by.

func (*Client) DeleteComputerInvitationByName 

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

DeleteComputerInvitationByName deletes a computer invitation by invitation.

Required privileges: enrollment-invitations:delete.

Parameters:

  • name: Invitation value to filter by.

func (*Client) DeleteDepartmentByID 

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

DeleteDepartmentByID deletes a department by ID.

Required privileges: departments:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteDepartmentByName 

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

DeleteDepartmentByName deletes a department by name.

Required privileges: departments:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteDirectoryBindingByID 

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

DeleteDirectoryBindingByID deletes a directory binding by ID.

Required privileges: directory-bindings:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteDirectoryBindingByName 

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

DeleteDirectoryBindingByName deletes a directory binding by name.

Required privileges: directory-bindings:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteDiskEncryptionConfigurationByID 

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

DeleteDiskEncryptionConfigurationByID deletes a disk encryption configuration by ID.

Required privileges: disk-encryption-configurations:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteDiskEncryptionConfigurationByName 

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

DeleteDiskEncryptionConfigurationByName deletes a disk encryption configuration by name.

Required privileges: disk-encryption-configurations:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteDistributionPointByID 

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

DeleteDistributionPointByID deletes a distribution point by ID.

Required privileges: distribution-points:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteDistributionPointByName 

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

DeleteDistributionPointByName deletes a distribution point by name.

Required privileges: distribution-points:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteDockItemByID 

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

DeleteDockItemByID deletes a dock item by ID.

Required privileges: dock-items:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteDockItemByName 

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

DeleteDockItemByName deletes a dock item by name.

Required privileges: dock-items:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteEbookByID 

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

DeleteEbookByID deletes an ebook by ID.

Required privileges: ebooks:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteEbookByName 

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

DeleteEbookByName deletes an ebook by name.

Required privileges: ebooks:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteIBeaconByID 

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

DeleteIBeaconByID deletes an iBeacon region by ID.

Required privileges: ibeacon:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteIBeaconByName 

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

DeleteIBeaconByName deletes an iBeacon region by name.

Required privileges: ibeacon:delete.

Parameters:

  • name: Name to filter by.

func (*Client) DeleteInfrastructureManagerByID 

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

DeleteInfrastructureManagerByID updates an existing infrastructure manager by ID.

Required privileges: infrastructure-managers:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteJsonWebTokenConfigurationByID 

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

DeleteJsonWebTokenConfigurationByID deletes a JSON Web Token configuration by ID.

Required privileges: json-web-token-configuration:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteLDAPServerByID 

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

DeleteLDAPServerByID deletes an LDAP server by ID.

Required privileges: ldap-servers:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteLDAPServerByName 

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

DeleteLDAPServerByName deletes an LDAP server by name.

Required privileges: ldap-servers:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteLicensedSoftwareByID 

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

DeleteLicensedSoftwareByID deletes licensed software by ID.

Required privileges: licensed-software:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteLicensedSoftwareByName 

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

DeleteLicensedSoftwareByName deletes licensed software by name.

Required privileges: licensed-software:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteLogFlush 

func (c *Client) DeleteLogFlush(ctx context.Context, request *Logflush) error

DeleteLogFlush flushes a log specified in an XML file.

Required privileges: flush-policy-logs:execute.

func (*Client) DeleteLogFlushByLogIDInterval 

func (c *Client) DeleteLogFlushByLogIDInterval(ctx context.Context, log string, id string, interval string) error

DeleteLogFlushByLogIDInterval flushes a single log for a given interval.

Required privileges: flush-policy-logs:execute.

Parameters:

  • log: At this time, only 'policy' logs are supported. Allowed values: "policy".
  • id: ID of policy whose log will be flushed.
  • interval: Supported values are a combination of [Zero, One, Two, Three, Six] and [Days, Weeks, Months, Years]. For example, JSSResource/logflush/policies/id/1/interval/Three+Months.

func (*Client) DeleteLogFlushByLogInterval 

func (c *Client) DeleteLogFlushByLogInterval(ctx context.Context, log string, interval string) error

DeleteLogFlushByLogInterval flushes all logs for a given interval.

Required privileges: flush-policy-logs:execute.

Parameters:

  • log: At this time, only 'policy' logs are supported. Allowed values: "policy".
  • interval: Supported values are a combination of [Zero, One, Two, Three, Six] and [Days, Weeks, Months, Years]. For example, JSSResource/logflush/policies/interval/Three+Months.

func (*Client) DeleteMacApplicationByID 

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

DeleteMacApplicationByID deletes a mac application by ID.

Required privileges: applications:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteMacApplicationByName 

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

DeleteMacApplicationByName deletes a mac application by name.

Required privileges: applications:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteMobileDeviceApplicationByBundleID 

func (c *Client) DeleteMobileDeviceApplicationByBundleID(ctx context.Context, bundleid string) error

DeleteMobileDeviceApplicationByBundleID deletes a mobile device application by bundle ID.

Required privileges: applications:delete.

Parameters:

  • bundleid: Bundle ID value to filter by.

func (*Client) DeleteMobileDeviceApplicationByBundleIDVersion 

func (c *Client) DeleteMobileDeviceApplicationByBundleIDVersion(ctx context.Context, bundleid string, version string) error

DeleteMobileDeviceApplicationByBundleIDVersion deletes a mobile device application by bundle ID and version.

Required privileges: applications:delete.

Parameters:

  • bundleid: Bundle ID value to filter by.
  • version: Version to filter by.

func (*Client) DeleteMobileDeviceApplicationByID 

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

DeleteMobileDeviceApplicationByID deletes a mobile device application by ID.

Required privileges: applications:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteMobileDeviceApplicationByName 

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

DeleteMobileDeviceApplicationByName deletes a mobile device application by name.

Required privileges: applications:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteMobileDeviceByID 

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

DeleteMobileDeviceByID deletes a mobile device by ID.

Required privileges: destructive-device-actions:execute.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteMobileDeviceByMacAddress 

func (c *Client) DeleteMobileDeviceByMacAddress(ctx context.Context, macAddress string) error

DeleteMobileDeviceByMacAddress deletes a mobile device by Mac address.

Required privileges: destructive-device-actions:execute.

Parameters:

  • macAddress: Mac address value to filter by.

func (*Client) DeleteMobileDeviceByName 

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

DeleteMobileDeviceByName deletes a mobile device by name.

Required privileges: destructive-device-actions:execute.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteMobileDeviceBySerialNumber 

func (c *Client) DeleteMobileDeviceBySerialNumber(ctx context.Context, serialNumber string) error

DeleteMobileDeviceBySerialNumber deletes a mobile device by serial number.

Required privileges: destructive-device-actions:execute.

Parameters:

  • serialNumber: Serial number value to filter by.

func (*Client) DeleteMobileDeviceByUDID 

func (c *Client) DeleteMobileDeviceByUDID(ctx context.Context, udid string) error

DeleteMobileDeviceByUDID deletes a mobile device by UDID.

Required privileges: destructive-device-actions:execute.

Parameters:

  • udid: UDID value to filter by.

func (*Client) DeleteMobileDeviceConfigurationProfileByID 

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

DeleteMobileDeviceConfigurationProfileByID deletes a mobile device configuration profile by ID.

Required privileges: configuration-profiles:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteMobileDeviceConfigurationProfileByName 

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

DeleteMobileDeviceConfigurationProfileByName deletes a mobile device configuration profile by name.

Required privileges: configuration-profiles:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteMobileDeviceEnrollmentProfileByID 

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

DeleteMobileDeviceEnrollmentProfileByID deletes a mobile device enrollment profile by ID.

Required privileges: enrollment-profiles:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteMobileDeviceEnrollmentProfileByInvitation 

func (c *Client) DeleteMobileDeviceEnrollmentProfileByInvitation(ctx context.Context, invitation string) error

DeleteMobileDeviceEnrollmentProfileByInvitation deletes a mobile device enrollment profile by invitation.

Required privileges: enrollment-profiles:delete.

Parameters:

  • invitation: Invitation value to filter by.

func (*Client) DeleteMobileDeviceEnrollmentProfileByName 

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

DeleteMobileDeviceEnrollmentProfileByName deletes a mobile device enrollment profile by name.

Required privileges: enrollment-profiles:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteMobileDeviceExtensionAttributeByID 

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

DeleteMobileDeviceExtensionAttributeByID deletes a mobile device extension attribute by ID.

Required privileges: extension-attributes:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteMobileDeviceExtensionAttributeByName 

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

DeleteMobileDeviceExtensionAttributeByName deletes a mobile device extension attribute by name.

Required privileges: extension-attributes:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteMobileDeviceGroupByID 

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

DeleteMobileDeviceGroupByID deletes a mobile device group by ID.

Required privileges: device-groups:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteMobileDeviceGroupByName 

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

DeleteMobileDeviceGroupByName deletes a mobile device group by name.

Required privileges: device-groups:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteMobileDeviceInvitationByID 

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

DeleteMobileDeviceInvitationByID deletes a mobile device invitation by id.

Required privileges: enrollment-invitations:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteMobileDeviceInvitationByInvitation 

func (c *Client) DeleteMobileDeviceInvitationByInvitation(ctx context.Context, invitation string) error

DeleteMobileDeviceInvitationByInvitation deletes a mobile device invitation by invitation.

Required privileges: enrollment-invitations:delete.

Parameters:

  • invitation: Invitation value to filter by.

func (*Client) DeleteMobileDeviceProvisioningProfileByID 

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

DeleteMobileDeviceProvisioningProfileByID deletes a mobile device provisioning profiles by id.

Required privileges: provisioning-profiles:delete.

Parameters:

  • id: Id value to filter by.

func (*Client) DeleteMobileDeviceProvisioningProfileByName 

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

DeleteMobileDeviceProvisioningProfileByName deletes a mobile device provisioning profiles by name.

Required privileges: provisioning-profiles:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteMobileDeviceProvisioningProfileByUUID 

func (c *Client) DeleteMobileDeviceProvisioningProfileByUUID(ctx context.Context, uuid string) error

DeleteMobileDeviceProvisioningProfileByUUID deletes a mobile device provisioning profiles by uuid.

Required privileges: provisioning-profiles:delete.

Parameters:

  • uuid: Uuid value to filter by.

func (*Client) DeleteNetworkSegmentByID 

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

DeleteNetworkSegmentByID deletes a network segment by ID.

Required privileges: network-segments:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteNetworkSegmentByName 

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

DeleteNetworkSegmentByName deletes a network segment by name.

Required privileges: network-segments:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteOSXConfigurationProfileByID 

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

DeleteOSXConfigurationProfileByID deletes a OS X configuration profile by ID.

Required privileges: configuration-profiles:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteOSXConfigurationProfileByName 

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

DeleteOSXConfigurationProfileByName deletes a OS X configuration profile by name.

Required privileges: configuration-profiles:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeletePatchByID deprecated 

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

DeletePatchByID deletes a Patch Software Title by ID (Deprecated - Please transition use to Jamf Pro API endpoint "/v2/patch-software-title-configurations/{id}".).

Deprecated: this endpoint is marked deprecated in the Jamf API spec and may be removed in a future release.

Required privileges: patch-management-software-titles:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeletePatchExternalSourceByID 

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

DeletePatchExternalSourceByID deletes a patch external source by ID.

Required privileges: patch-external-source:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeletePatchExternalSourceByName 

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

DeletePatchExternalSourceByName deletes a patch external source by ID.

Required privileges: patch-external-source:delete.

Parameters:

  • name: ID value to filter by.

func (*Client) DeletePatchPolicyByID 

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

DeletePatchPolicyByID deletes a patch policy by ID.

Required privileges: patch-policies:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeletePatchSoftwareTitleByID deprecated 

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

DeletePatchSoftwareTitleByID deletes a patch software title by ID. (Deprecated) Please transition use to Jamf Pro API endpoint "/v2/patch-software-title-configurations/{id}".

Deprecated: this endpoint is marked deprecated in the Jamf API spec and may be removed in a future release.

Required privileges: patch-management-software-titles:delete.

Parameters:

  • id: ID value to update by.

func (*Client) DeletePolicyByID 

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

DeletePolicyByID deletes a policy by ID.

Required privileges: policies:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeletePolicyByName 

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

DeletePolicyByName deletes a policy by name.

Required privileges: policies:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeletePrinterByID 

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

DeletePrinterByID deletes a printer by ID.

Required privileges: printers:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeletePrinterByName 

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

DeletePrinterByName deletes a printer by name.

Required privileges: printers:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteRemovableMacAddressByID 

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

DeleteRemovableMacAddressByID deletes a removable Mac address by ID.

Required privileges: removable-mac-address:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteRemovableMacAddressByName 

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

DeleteRemovableMacAddressByName deletes a removable Mac address by name.

Required privileges: removable-mac-address:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteRestrictedSoftwareByID 

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

DeleteRestrictedSoftwareByID deletes a restricted software by ID.

Required privileges: restricted-software:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteRestrictedSoftwareByName 

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

DeleteRestrictedSoftwareByName deletes a restricted software by name.

Required privileges: restricted-software:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteScriptByID 

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

DeleteScriptByID deletes a script by ID.

Required privileges: scripts:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteScriptByName 

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

DeleteScriptByName deletes a script by name.

Required privileges: scripts:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteSiteByID 

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

DeleteSiteByID deletes a site by ID.

Required privileges: sites:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteSiteByName 

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

DeleteSiteByName deletes a site by name.

Required privileges: sites:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteSoftwareUpdateServerByID 

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

DeleteSoftwareUpdateServerByID deletes a software update server by ID.

Required privileges: software-update-servers:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteSoftwareUpdateServerByName 

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

DeleteSoftwareUpdateServerByName deletes a software update server by name.

Required privileges: software-update-servers:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteUserByID 

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

DeleteUserByID deletes a user by ID.

Required privileges: users:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteUserByName 

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

DeleteUserByName deletes a user by name.

Required privileges: users:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteUserExtensionAttributeByID 

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

DeleteUserExtensionAttributeByID deletes a user extension attribute by ID.

Required privileges: user-extension-attributes:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteUserExtensionAttributeByName 

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

DeleteUserExtensionAttributeByName deletes a user extension attribute by name.

Required privileges: user-extension-attributes:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteUserGroupByID 

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

DeleteUserGroupByID deletes user groups by ID.

Required privileges: user-groups:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteUserGroupByName 

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

DeleteUserGroupByName deletes user groups by name.

Required privileges: user-groups:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) DeleteVPPAccountByID 

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

DeleteVPPAccountByID deletes a VPP account by ID.

Required privileges: volume-purchasing-locations:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteVPPAssignmentByID 

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

DeleteVPPAssignmentByID deletes a VPP assignment by ID.

Required privileges: volume-purchasing-locations:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteVPPInvitationByID 

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

DeleteVPPInvitationByID deletes a VPP invitation by ID.

Required privileges: volume-purchasing-locations:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteWebhookByID 

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

DeleteWebhookByID deletes a webhook by ID.

Required privileges: webhooks:delete.

Parameters:

  • id: ID value to filter by.

func (*Client) DeleteWebhookByName 

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

DeleteWebhookByName deletes a webhook by name.

Required privileges: webhooks:delete.

Parameters:

  • name: Name value to filter by.

func (*Client) GetAccountByUserID 

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

GetAccountByUserID finds accounts by ID.

Required privileges: accounts:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetAccountByUsername 

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

GetAccountByUsername finds accounts by name.

Required privileges: accounts:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetAccountGroupByID 

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

GetAccountGroupByID finds groups by ID.

Required privileges: accounts:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetAccountGroupByName 

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

GetAccountGroupByName finds groups by name.

Required privileges: accounts:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetActivationCode deprecated 

func (c *Client) GetActivationCode(ctx context.Context) (*ActivationCode, error)

GetActivationCode finds the Jamf Pro activation code.

Deprecated: this endpoint is marked deprecated in the Jamf API spec (deprecation-date: 2026-07-14) and may be removed in a future release.

Required privileges: activation-code:read.

No successor exists. The deprecation above says the endpoint may be removed, but the Jamf Pro API publishes no `GET /v1/activation-code` in any environment — only `PUT /v1/activation-code` and `PATCH /v1/activation-code/organization-name` — and no other Classic operation returns the activation code. So this remains the only way to read it, it answers 200 with real data, and there is nothing to migrate to. Reported upstream.

func (*Client) GetAdvancedComputerSearchByID 

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

GetAdvancedComputerSearchByID finds computer searches by ID.

Required privileges: advanced-device-searches:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetAdvancedComputerSearchByName 

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

GetAdvancedComputerSearchByName finds advanced computer searches by name.

Required privileges: advanced-device-searches:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetAdvancedMobileDeviceSearchByID 

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

GetAdvancedMobileDeviceSearchByID finds mobile device searches by ID.

Required privileges: advanced-device-searches:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetAdvancedMobileDeviceSearchByName 

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

GetAdvancedMobileDeviceSearchByName finds advanced mobile device searches by name.

Required privileges: advanced-device-searches:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetAdvancedUserSearchByID 

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

GetAdvancedUserSearchByID finds user searches by ID.

Required privileges: advanced-user-searches:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetAdvancedUserSearchByName 

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

GetAdvancedUserSearchByName finds user searches by name.

Required privileges: advanced-user-searches:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetAllowedFileExtensionByExtension 

func (c *Client) GetAllowedFileExtensionByExtension(ctx context.Context, extension string) (*AllowedFileExtension, error)

GetAllowedFileExtensionByExtension finds an allowed file extension value by name.

Required privileges: allowed-file-extension:read.

Parameters:

  • extension: String value of extension.

func (*Client) GetAllowedFileExtensionByID 

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

GetAllowedFileExtensionByID finds an allowed file extension value by ID.

Required privileges: allowed-file-extension:read.

Parameters:

  • id: Database ID of the extension.

func (*Client) GetBuildingByID 

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

GetBuildingByID finds buildings by ID.

Required privileges: buildings:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetBuildingByName 

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

GetBuildingByName finds buildings by name.

Required privileges: buildings:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetCategoryByID 

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

GetCategoryByID finds categories by ID.

Required privileges: categories:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetCategoryByName 

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

GetCategoryByName finds categories by name.

Required privileges: categories:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetClassByID 

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

GetClassByID finds classes by ID.

Required privileges: classes:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetClassByName 

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

GetClassByName finds classes by name.

Required privileges: classes:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetClassicPackageByID 

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

GetClassicPackageByID finds packages by ID.

Required privileges: packages:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetClassicPackageByName 

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

GetClassicPackageByName finds packages by name.

Required privileges: packages:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetComputerApplicationByApplication 

func (c *Client) GetComputerApplicationByApplication(ctx context.Context, application string) (*ComputerApplications, error)

GetComputerApplicationByApplication finds computer applications by name.

Required privileges: advanced-device-searches:read.

Parameters:

  • application: Application name to filter by.

func (*Client) GetComputerApplicationByApplicationInventory 

func (c *Client) GetComputerApplicationByApplicationInventory(ctx context.Context, application string, inventory string) (*ComputerApplications, error)

GetComputerApplicationByApplicationInventory finds computer applications by name with additional display fields.

Required privileges: advanced-device-searches:read.

Parameters:

  • application: Application name to filter by.
  • inventory: Inventory options.

func (*Client) GetComputerApplicationByApplicationVersion 

func (c *Client) GetComputerApplicationByApplicationVersion(ctx context.Context, application string, version string) (*ComputerApplications, error)

GetComputerApplicationByApplicationVersion finds computer applications by name and version.

Required privileges: advanced-device-searches:read.

Parameters:

  • application: Application name to filter by.
  • version: Version to filter by.

func (*Client) GetComputerApplicationByApplicationVersionInventory 

func (c *Client) GetComputerApplicationByApplicationVersionInventory(ctx context.Context, application string, version string, inventory string) (*ComputerApplications, error)

GetComputerApplicationByApplicationVersionInventory finds computer applications by name and version.

Required privileges: advanced-device-searches:read.

Parameters:

  • application: Application name to filter by.
  • version: Version to filter by.
  • inventory: Inventory options.

func (*Client) GetComputerApplicationUsageByID 

func (c *Client) GetComputerApplicationUsageByID(ctx context.Context, id string, startDate string, endDate string) (*ComputerApplicationUsage, error)

GetComputerApplicationUsageByID finds computer application usage by computer ID.

Required privileges: device-history:read.

Parameters:

  • id: ID value to filter by.
  • startDate: Start date (e.g. yyyy-mm-dd).
  • endDate: End date (e.g. yyyy-mm-dd).

func (*Client) GetComputerApplicationUsageByMacAddressDateRange 

func (c *Client) GetComputerApplicationUsageByMacAddressDateRange(ctx context.Context, macaddress string, start_date string, end_date string) (*ComputerApplicationUsage, error)

GetComputerApplicationUsageByMacAddressDateRange finds computer application usage by computer MAC address.

Required privileges: device-history:read.

Parameters:

  • macaddress: MAC address to filter by.
  • start_date: Start date (e.g. yyyy-mm-dd).
  • end_date: End date (e.g. yyyy-mm-dd).

func (*Client) GetComputerApplicationUsageByNameDateRange 

func (c *Client) GetComputerApplicationUsageByNameDateRange(ctx context.Context, name string, start_date string, end_date string) (*ComputerApplicationUsage, error)

GetComputerApplicationUsageByNameDateRange finds computer application usage by computer name.

Required privileges: device-history:read.

Parameters:

  • name: Name to filter by.
  • start_date: Start date (e.g. yyyy-mm-dd).
  • end_date: End date (e.g. yyyy-mm-dd).

func (*Client) GetComputerApplicationUsageBySerialNumberDateRange 

func (c *Client) GetComputerApplicationUsageBySerialNumberDateRange(ctx context.Context, serialnumber string, start_date string, end_date string) (*ComputerApplicationUsage, error)

GetComputerApplicationUsageBySerialNumberDateRange finds computer application usage by computer serial number.

Required privileges: device-history:read.

Parameters:

  • serialnumber: Serial number to filter by.
  • start_date: Start date (e.g. yyyy-mm-dd).
  • end_date: End date (e.g. yyyy-mm-dd).

func (*Client) GetComputerApplicationUsageByUDIDDateRange 

func (c *Client) GetComputerApplicationUsageByUDIDDateRange(ctx context.Context, udid string, start_date string, end_date string) (*ComputerApplicationUsage, error)

GetComputerApplicationUsageByUDIDDateRange finds computer application usage by computer UDID.

Required privileges: device-history:read.

Parameters:

  • udid: UDID to filter by.
  • start_date: Start date (e.g. yyyy-mm-dd).
  • end_date: End date (e.g. yyyy-mm-dd).

func (*Client) GetComputerCheckIn 

func (c *Client) GetComputerCheckIn(ctx context.Context) (*ComputerCheckIn, error)

GetComputerCheckIn finds the Jamf Pro computer checkin information.

Required privileges: computer-check-in:read.

func (*Client) GetComputerCommandByName 

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

GetComputerCommandByName finds all computer commands by name.

Required privileges: device-actions:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetComputerCommandByUUID 

func (c *Client) GetComputerCommandByUUID(ctx context.Context, uuid string) (*ComputerCommand, error)

GetComputerCommandByUUID finds a computer command by UUID.

Required privileges: device-actions:read.

Parameters:

  • uuid: UUID to filter by.

func (*Client) GetComputerCommandsByCommand 

func (c *Client) GetComputerCommandsByCommand(ctx context.Context, command string) (*ComputerCommand, error)

GetComputerCommandsByCommand finds all computer commands by name.

Required privileges: device-actions:read.

Parameters:

  • command: Name to filter by.

func (*Client) GetComputerCommandsByStatus 

func (c *Client) GetComputerCommandsByStatus(ctx context.Context, uuid string) (*ComputerCommand, error)

GetComputerCommandsByStatus finds a computer command by UUID.

Required privileges: device-actions:read.

Parameters:

  • uuid: UUID to filter by.

func (*Client) GetComputerExtensionAttributeByID 

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

GetComputerExtensionAttributeByID finds computer extension attributes by ID.

Required privileges: extension-attributes:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetComputerExtensionAttributeByName 

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

GetComputerExtensionAttributeByName finds computer extension attributes by name.

Required privileges: extension-attributes:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetComputerGroupByID 

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

GetComputerGroupByID finds computer groups by ID.

Required privileges: device-groups:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetComputerGroupByName 

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

GetComputerGroupByName finds computer groups by name.

Required privileges: device-groups:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetComputerHardwareSoftwareReportByIDDateRange 

func (c *Client) GetComputerHardwareSoftwareReportByIDDateRange(ctx context.Context, id string, start_date string, end_date string) (*ComputerHardwareSoftwareReports, error)

GetComputerHardwareSoftwareReportByIDDateRange finds hardware/software reports by computer ID.

Required privileges: device-history:read.

Parameters:

  • id: ID value to filter by.
  • start_date: Start date (e.g. yyyy-mm-dd).
  • end_date: End date (e.g. yyyy-mm-dd).

func (*Client) GetComputerHardwareSoftwareReportByIDDateRangeSubset 

func (c *Client) GetComputerHardwareSoftwareReportByIDDateRangeSubset(ctx context.Context, id string, start_date string, end_date string, subset string) (*ComputerHardwareSoftwareReports, error)

GetComputerHardwareSoftwareReportByIDDateRangeSubset finds a subset of hardware/software reports by computer ID.

Required privileges: device-history:read.

Parameters:

  • id: Computer ID to filter by.
  • start_date: Start date (e.g. yyyy-mm-dd).
  • end_date: End date (e.g. yyyy-mm-dd).
  • subset: Subset to filter by. Allowed values: "Software", "Hardwre", "Fonts", "Plugins".

func (*Client) GetComputerHardwareSoftwareReportByMacAddressDateRange 

func (c *Client) GetComputerHardwareSoftwareReportByMacAddressDateRange(ctx context.Context, macaddress string, start_date string, end_date string) (*ComputerHardwareSoftwareReports, error)

GetComputerHardwareSoftwareReportByMacAddressDateRange finds hardware/software reports by computer MAC address.

Required privileges: device-history:read.

Parameters:

  • macaddress: MAC address to filter by.
  • start_date: Start date (e.g. yyyy-mm-dd).
  • end_date: End date (e.g. yyyy-mm-dd).

func (*Client) GetComputerHardwareSoftwareReportByNameDateRange 

func (c *Client) GetComputerHardwareSoftwareReportByNameDateRange(ctx context.Context, name string, start_date string, end_date string) (*ComputerHardwareSoftwareReports, error)

GetComputerHardwareSoftwareReportByNameDateRange finds hardware/software reports by computer name.

Required privileges: device-history:read.

Parameters:

  • name: Name to filter by.
  • start_date: Start date (e.g. yyyy-mm-dd).
  • end_date: End date (e.g. yyyy-mm-dd).

func (*Client) GetComputerHardwareSoftwareReportBySerialNumberDateRange 

func (c *Client) GetComputerHardwareSoftwareReportBySerialNumberDateRange(ctx context.Context, serialnumber string, start_date string, end_date string) (*ComputerHardwareSoftwareReports, error)

GetComputerHardwareSoftwareReportBySerialNumberDateRange finds hardware/software reports by computer serial number.

Required privileges: device-history:read.

Parameters:

  • serialnumber: Serial number to filter by.
  • start_date: Start date (e.g. yyyy-mm-dd).
  • end_date: End date (e.g. yyyy-mm-dd).

func (*Client) GetComputerHardwareSoftwareReportByUDIDDateRange 

func (c *Client) GetComputerHardwareSoftwareReportByUDIDDateRange(ctx context.Context, udid string, start_date string, end_date string) (*ComputerHardwareSoftwareReports, error)

GetComputerHardwareSoftwareReportByUDIDDateRange finds hardware/software reports by computer UDID.

Required privileges: device-history:read.

Parameters:

  • udid: UDID to filter by.
  • start_date: Start date (e.g. yyyy-mm-dd).
  • end_date: End date (e.g. yyyy-mm-dd).

func (*Client) GetComputerHistoryByID 

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

GetComputerHistoryByID finds computer history by ID.

Required privileges: device-history:read.

Parameters:

  • id: Computer ID value to filter by.

func (*Client) GetComputerHistoryByIDSubset 

func (c *Client) GetComputerHistoryByIDSubset(ctx context.Context, id string, subset string) (*ComputerHistory, error)

GetComputerHistoryByIDSubset finds a subset of computer history data by ID.

Required privileges: device-history:read.

Parameters:

  • id: Computer ID to filter by.
  • subset: Subset to filter by. Allowed values: "General", "ComputerUsageLogs", "Audits", "PolicyLogs", "CasperRemoteLogs", "ScreenSharingLogs", "CasperImagingLogs", "Commands", "UserLocation", "MacAppStoreApplications".

func (*Client) GetComputerHistoryByMacAddress 

func (c *Client) GetComputerHistoryByMacAddress(ctx context.Context, macAddress string) (*ComputerHistory, error)

GetComputerHistoryByMacAddress finds computer history by MAC address.

Required privileges: device-history:read.

Parameters:

  • macAddress: Computer Mac Address to filter by.

func (*Client) GetComputerHistoryByName 

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

GetComputerHistoryByName finds computer history by name.

Required privileges: device-history:read.

Parameters:

  • name: Computer Name to filter by.

func (*Client) GetComputerHistoryBySerialNumber 

func (c *Client) GetComputerHistoryBySerialNumber(ctx context.Context, serialNumber string) (*ComputerHistory, error)

GetComputerHistoryBySerialNumber finds computer history by serial number.

Required privileges: device-history:read.

Parameters:

  • serialNumber: Computer Serial Number to filter by.

func (*Client) GetComputerHistoryByUDID 

func (c *Client) GetComputerHistoryByUDID(ctx context.Context, udid string) (*ComputerHistory, error)

GetComputerHistoryByUDID finds computer history by UDID.

Required privileges: device-history:read.

Parameters:

  • udid: Computer UDID to filter by.

func (*Client) GetComputerInventoryCollection 

func (c *Client) GetComputerInventoryCollection(ctx context.Context) (*ComputerInventoryCollection, error)

GetComputerInventoryCollection finds the Jamf Pro computer inventory collection information.

Required privileges: computer-inventory-collection-settings:read.

func (*Client) GetComputerInvitationByID 

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

GetComputerInvitationByID finds computer invitations by id.

Required privileges: enrollment-invitations:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetComputerInvitationByInvitation 

func (c *Client) GetComputerInvitationByInvitation(ctx context.Context, invitation string) (*ComputerInvitation, error)

GetComputerInvitationByInvitation finds computer invitations by invitation.

Required privileges: enrollment-invitations:read.

Parameters:

  • invitation: Invitation value to filter by.

func (*Client) GetComputerInvitationByName 

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

GetComputerInvitationByName finds computer invitations by invitation.

Required privileges: enrollment-invitations:read.

Parameters:

  • name: Invitation value to filter by.

func (*Client) GetComputerManagementByID 

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

GetComputerManagementByID finds computer management information by ID.

Required privileges: device-history:read.

Parameters:

  • id: Computer ID value to filter by.

func (*Client) GetComputerManagementByIDPatchFilter 

func (c *Client) GetComputerManagementByIDPatchFilter(ctx context.Context, id string, filter string) (*ComputerManagement, error)

GetComputerManagementByIDPatchFilter display patch management information for a computer and filter.

Required privileges: device-history:read.

Parameters:

  • id: Computer ID to filter by.
  • filter: filter to apply.

func (*Client) GetComputerManagementByIDSubset 

func (c *Client) GetComputerManagementByIDSubset(ctx context.Context, id string, subset string) (*ComputerManagement, error)

GetComputerManagementByIDSubset finds a subset of computer management information by ID.

Required privileges: device-history:read.

Parameters:

  • id: Computer ID value to filter by.
  • subset: Subset to filter by. Allowed values: "General", "Policies", "Ebooks", "MacAppStoreApps", "OSXConfigurationProfiles", "RestrictedSoftware", "SmartGroups", "StaticGroups", "PatchReportingSoftwareTitles".

func (*Client) GetComputerManagementByIDUsername 

func (c *Client) GetComputerManagementByIDUsername(ctx context.Context, id string, username string) (*ComputerManagement, error)

GetComputerManagementByIDUsername finds management information for a computer and username.

Required privileges: device-history:read.

Parameters:

  • id: Computer ID to filter by.
  • username: Username to filter by.

func (*Client) GetComputerManagementByIDUsernameSubset 

func (c *Client) GetComputerManagementByIDUsernameSubset(ctx context.Context, id string, username string, subset string) (*ComputerManagement, error)

GetComputerManagementByIDUsernameSubset finds a subset of management information for a computer and username.

Required privileges: device-history:read.

Parameters:

  • id: Computer ID to filter by.
  • username: Username to filter by.
  • subset: Subset to filter by. Allowed values: "General", "Policies", "Ebooks", "MacAppStoreApps", "OSXConfigurationProfiles", "RestrictedSoftware", "SmartGroups", "StaticGroups", "PatchReportingSoftwareTitles".

func (*Client) GetComputerManagementByMacAddress 

func (c *Client) GetComputerManagementByMacAddress(ctx context.Context, macAddress string) (*ComputerManagement, error)

GetComputerManagementByMacAddress finds computer management information by MAC address.

Required privileges: device-history:read.

Parameters:

  • macAddress: Computer Mac Address to filter by.

func (*Client) GetComputerManagementByName 

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

GetComputerManagementByName finds computer management information by name.

Required privileges: device-history:read.

Parameters:

  • name: Computer Name to filter by.

func (*Client) GetComputerManagementBySerialNumber 

func (c *Client) GetComputerManagementBySerialNumber(ctx context.Context, serialNumber string) (*ComputerManagement, error)

GetComputerManagementBySerialNumber finds computer management information by serial number.

Required privileges: device-history:read.

Parameters:

  • serialNumber: Computer Serial Number to filter by.

func (*Client) GetComputerManagementByUDID 

func (c *Client) GetComputerManagementByUDID(ctx context.Context, udid string) (*ComputerManagement, error)

GetComputerManagementByUDID finds computer management information by UDID.

Required privileges: device-history:read.

Parameters:

  • udid: Computer UDID to filter by.

func (*Client) GetComputerReportByID 

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

GetComputerReportByID finds computer reports by id.

Required privileges: device-history:read.

Parameters:

  • id: Computer Report ID to filter by.

func (*Client) GetComputerReportByName 

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

GetComputerReportByName finds computer reports by name.

Required privileges: device-history:read.

Parameters:

  • name: Computer Report name to filter by.

func (*Client) GetDepartmentByID 

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

GetDepartmentByID finds departments by ID.

Required privileges: departments:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetDepartmentByName 

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

GetDepartmentByName finds departments by name.

Required privileges: departments:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetDirectoryBindingByID 

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

GetDirectoryBindingByID finds directory bindings by ID.

Required privileges: directory-bindings:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetDirectoryBindingByName 

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

GetDirectoryBindingByName finds directory bindings by name.

Required privileges: directory-bindings:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetDiskEncryptionConfigurationByID 

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

GetDiskEncryptionConfigurationByID finds disk encryption configurations by ID.

Required privileges: disk-encryption-configurations:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetDiskEncryptionConfigurationByName 

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

GetDiskEncryptionConfigurationByName finds disk encryption configurations by name.

Required privileges: disk-encryption-configurations:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetDistributionPointByID 

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

GetDistributionPointByID finds distribution points by ID.

Required privileges: distribution-points:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetDistributionPointByName 

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

GetDistributionPointByName finds distribution points by name.

Required privileges: distribution-points:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetDockItemByID 

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

GetDockItemByID finds dock items by ID.

Required privileges: dock-items:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetDockItemByName 

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

GetDockItemByName finds dock items by name.

Required privileges: dock-items:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetEbookByID 

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

GetEbookByID finds ebooks by ID.

Required privileges: ebooks:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetEbookByIDSubset 

func (c *Client) GetEbookByIDSubset(ctx context.Context, id string, subset string) (*Ebook, error)

GetEbookByIDSubset finds a subset of data for an ebook by ID.

Required privileges: ebooks:read.

Parameters:

  • id: ID to filter by.
  • subset: Subset to filter by. Allowed values: "General", "Scope", "SelfService".

func (*Client) GetEbookByName 

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

GetEbookByName finds ebooks by name.

Required privileges: ebooks:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetGSXConnection 

func (c *Client) GetGSXConnection(ctx context.Context) (*GsxConnection, error)

GetGSXConnection finds the Jamf Pro GSX connection information.

Required privileges: gsx-connection:read.

func (*Client) GetHealthcareListenerByID 

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

GetHealthcareListenerByID finds healthcare listener by ID.

Required privileges: infrastructure-managers:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetHealthcareListenerRuleByID 

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

GetHealthcareListenerRuleByID finds Healthcare Listener rules by ID.

Required privileges: infrastructure-managers:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetIBeaconByID 

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

GetIBeaconByID finds iBeacon regions by ID.

Required privileges: ibeacon:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetIBeaconByName 

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

GetIBeaconByName finds iBeacon regions by name.

Required privileges: ibeacon:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetInfrastructureManagerByID 

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

GetInfrastructureManagerByID finds infrastructure manager by ID.

Required privileges: infrastructure-managers:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetJSSUser deprecated 

func (c *Client) GetJSSUser(ctx context.Context) (*JssUser, error)

GetJSSUser returns basic information about Jamf Pro, as well as privileges of the person requesting the resource. (Deprecated).

Deprecated: this endpoint is marked deprecated in the Jamf API spec and may be removed in a future release.

Required privileges: accounts:read.

func (*Client) GetJsonWebTokenConfigurationByID 

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

GetJsonWebTokenConfigurationByID find JSON Web Token configuration by ID.

Required privileges: json-web-token-configuration:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetLDAPServerByID 

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

GetLDAPServerByID finds LDAP servers by ID.

Required privileges: ldap-servers:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetLDAPServerByIDGroup 

func (c *Client) GetLDAPServerByIDGroup(ctx context.Context, id string, group string) (*LdapServer, error)

GetLDAPServerByIDGroup display information for matching groups for an LDAP server.

Required privileges: ldap-servers:read.

Parameters:

  • id: Server ID to filter by.
  • group: Group to filter by.

func (*Client) GetLDAPServerByIDGroupUser 

func (c *Client) GetLDAPServerByIDGroupUser(ctx context.Context, id string, group string, user string) (*LdapServer, error)

GetLDAPServerByIDGroupUser display information about user membership in a group for an LDAP server.

Required privileges: ldap-servers:read.

Parameters:

  • id: Server ID to filter by.
  • group: Group to filter by.
  • user: User to filter by.

func (*Client) GetLDAPServerByIDUser 

func (c *Client) GetLDAPServerByIDUser(ctx context.Context, id string, user string) (*LdapServer, error)

GetLDAPServerByIDUser display information for matching users for an LDAP server.

Required privileges: ldap-servers:read.

Parameters:

  • id: Server ID to filter by.
  • user: User to filter by.

func (*Client) GetLDAPServerByName 

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

GetLDAPServerByName finds LDAP servers by name.

Required privileges: ldap-servers:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetLicensedSoftwareByID 

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

GetLicensedSoftwareByID finds licensed software by ID.

Required privileges: licensed-software:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetLicensedSoftwareByName 

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

GetLicensedSoftwareByName finds licensed software by name.

Required privileges: licensed-software:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetMacApplicationByID 

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

GetMacApplicationByID finds mac applications by ID.

Required privileges: applications:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetMacApplicationByIDSubset 

func (c *Client) GetMacApplicationByIDSubset(ctx context.Context, id string, subset string) (*MacApplication, error)

GetMacApplicationByIDSubset finds a subset of date for a mac application by ID.

Required privileges: applications:read.

Parameters:

  • id: ID to filter by.
  • subset: Subset to filter by. Allowed values: "General", "Scope", "SelfService", "VPPCodes", "VPP".

func (*Client) GetMacApplicationByName 

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

GetMacApplicationByName finds mac applications by name.

Required privileges: applications:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetMacApplicationByNameSubset 

func (c *Client) GetMacApplicationByNameSubset(ctx context.Context, name string, subset string) (*MacApplication, error)

GetMacApplicationByNameSubset finds a subset of data for mac applications by name.

Required privileges: applications:read.

Parameters:

  • name: Name to filter by.
  • subset: Subset to filter by. Allowed values: "General", "Scope", "SelfService", "VPPCodes", "VPP".

func (*Client) GetMobileDeviceApplicationByBundleID 

func (c *Client) GetMobileDeviceApplicationByBundleID(ctx context.Context, bundleID string) (*MobileDeviceApplication, error)

GetMobileDeviceApplicationByBundleID finds mobile device applications by bundle ID.

Required privileges: applications:read.

Parameters:

  • bundleID: Bundle ID to filter by.

func (*Client) GetMobileDeviceApplicationByBundleIDVersion 

func (c *Client) GetMobileDeviceApplicationByBundleIDVersion(ctx context.Context, bundleid string, version string) (*MobileDeviceApplication, error)

GetMobileDeviceApplicationByBundleIDVersion finds mobile device applications by bundle ID and version.

Required privileges: applications:read.

Parameters:

  • bundleid: Bundle ID to filter by.
  • version: Version to filter by.

func (*Client) GetMobileDeviceApplicationByID 

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

GetMobileDeviceApplicationByID finds mobile device applications by ID.

Required privileges: applications:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetMobileDeviceApplicationByIDSubset 

func (c *Client) GetMobileDeviceApplicationByIDSubset(ctx context.Context, id string, subset string) (*MobileDeviceApplication, error)

GetMobileDeviceApplicationByIDSubset finds a subset of data for a mobile device application by ID.

Required privileges: applications:read.

Parameters:

  • id: ID to filter by.
  • subset: Subset to filter by. Allowed values: "General", "Scope", "SelfService", "VPPCodes", "VPP", "AppConfiguration".

func (*Client) GetMobileDeviceApplicationByName 

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

GetMobileDeviceApplicationByName finds mobile device applications by name.

Required privileges: applications:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetMobileDeviceApplicationByNameSubset 

func (c *Client) GetMobileDeviceApplicationByNameSubset(ctx context.Context, name string, subset string) (*MobileDeviceApplication, error)

GetMobileDeviceApplicationByNameSubset finds a subset of data for mobile device applications by name.

Required privileges: applications:read.

Parameters:

  • name: Name to filter by.
  • subset: Subset to filter by. Allowed values: "General", "Scope", "SelfService", "VPPCodes", "VPP", "AppConfiguration".

func (*Client) GetMobileDeviceByID 

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

GetMobileDeviceByID finds mobile devices by ID.

Required privileges: devices:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetMobileDeviceByIDSubset 

func (c *Client) GetMobileDeviceByIDSubset(ctx context.Context, id string, subset string) (*MobileDevice, error)

GetMobileDeviceByIDSubset finds a subset of data for a mobile device.

Required privileges: devices:read.

Parameters:

  • id: ID to filter by.
  • subset: Subset to filter by. Allowed values: "General", "Location", "Purchasing", "Applications", "Security", "Network", "Certificates", "ConfigurationProfiles", "ProvisioningProfiles", "MobileDeviceGroups", "ExtensionAttributes".

func (*Client) GetMobileDeviceByMacAddress 

func (c *Client) GetMobileDeviceByMacAddress(ctx context.Context, macAddress string) (*MobileDevice, error)

GetMobileDeviceByMacAddress finds mobile devices by Mac address.

Required privileges: devices:read.

Parameters:

  • macAddress: Mac address to filter by.

func (*Client) GetMobileDeviceByMatch 

func (c *Client) GetMobileDeviceByMatch(ctx context.Context, match string) (*MobileDevice, error)

GetMobileDeviceByMatch searches for mobile devices that match the provided parameter.

Required privileges: devices:read.

Parameters:

  • match: Name, mac address, etc. to filter by. Match uses the same format as the general search in Jamf Pro.

func (*Client) GetMobileDeviceByName 

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

GetMobileDeviceByName finds mobile devices by name.

Required privileges: devices:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetMobileDeviceBySerialNumber 

func (c *Client) GetMobileDeviceBySerialNumber(ctx context.Context, serialNumber string) (*MobileDevice, error)

GetMobileDeviceBySerialNumber finds mobile devices by serial number.

Required privileges: devices:read.

Parameters:

  • serialNumber: Serial number to filter by.

func (*Client) GetMobileDeviceByUDID 

func (c *Client) GetMobileDeviceByUDID(ctx context.Context, udid string) (*MobileDevice, error)

GetMobileDeviceByUDID finds mobile devices by UDID.

Required privileges: devices:read.

Parameters:

  • udid: UDID to filter by.

func (*Client) GetMobileDeviceCommandByCommand 

func (c *Client) GetMobileDeviceCommandByCommand(ctx context.Context, command string) (*MobileDeviceCommand, error)

GetMobileDeviceCommandByCommand finds all mobile device commands for specified command.

Required privileges: device-actions:read.

Parameters:

  • command: Name to filter by.

func (*Client) GetMobileDeviceCommandByName 

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

GetMobileDeviceCommandByName finds all mobile device commands by command name.

Required privileges: device-actions:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetMobileDeviceCommandByUUID 

func (c *Client) GetMobileDeviceCommandByUUID(ctx context.Context, uuid string) (*MobileDeviceCommand, error)

GetMobileDeviceCommandByUUID finds a mobile device command by UUID.

Required privileges: device-actions:read.

Parameters:

  • uuid: UUID value to filter by.

func (*Client) GetMobileDeviceConfigurationProfileByID 

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

GetMobileDeviceConfigurationProfileByID finds mobile device configuration profiles by ID.

Required privileges: configuration-profiles:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetMobileDeviceConfigurationProfileByIDSubset 

func (c *Client) GetMobileDeviceConfigurationProfileByIDSubset(ctx context.Context, id string, subset string) (*MobileDeviceConfigurationProfile, error)

GetMobileDeviceConfigurationProfileByIDSubset finds a subset of data for a mobile device configuration profile by ID.

Required privileges: configuration-profiles:read.

Parameters:

  • id: ID to filter by.
  • subset: Subset to filter by. Allowed values: "General", "Scope", "SelfService".

func (*Client) GetMobileDeviceConfigurationProfileByName 

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

GetMobileDeviceConfigurationProfileByName finds mobile device configuration profiles by name.

Required privileges: configuration-profiles:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetMobileDeviceConfigurationProfileByNameSubset 

func (c *Client) GetMobileDeviceConfigurationProfileByNameSubset(ctx context.Context, name string, subset string) (*MobileDeviceConfigurationProfile, error)

GetMobileDeviceConfigurationProfileByNameSubset finds a subset of data for mobile device configuration profiles by name.

Required privileges: configuration-profiles:read.

Parameters:

  • name: Name to filter by.
  • subset: Subset to filter by. Allowed values: "General", "Scope", "SelfService".

func (*Client) GetMobileDeviceEnrollmentProfileByID 

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

GetMobileDeviceEnrollmentProfileByID finds mobile device enrollment profiles by ID.

Required privileges: enrollment-profiles:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetMobileDeviceEnrollmentProfileByIDSubset 

func (c *Client) GetMobileDeviceEnrollmentProfileByIDSubset(ctx context.Context, id string, subset string) (*MobileDeviceEnrollmentProfile, error)

GetMobileDeviceEnrollmentProfileByIDSubset finds a subset of data for an enrollment profile.

Required privileges: enrollment-profiles:read.

Parameters:

  • id: ID to filter by.
  • subset: Subset to filter by. Allowed values: "General", "Location", "Purchasing", "Attachments".

func (*Client) GetMobileDeviceEnrollmentProfileByInvitation 

func (c *Client) GetMobileDeviceEnrollmentProfileByInvitation(ctx context.Context, invitation string) (*MobileDeviceEnrollmentProfile, error)

GetMobileDeviceEnrollmentProfileByInvitation finds mobile device enrollment profiles by invitation.

Required privileges: enrollment-profiles:read.

Parameters:

  • invitation: Invitation value to filter by.

func (*Client) GetMobileDeviceEnrollmentProfileByInvitationSubset 

func (c *Client) GetMobileDeviceEnrollmentProfileByInvitationSubset(ctx context.Context, invitation string, subset string) (*MobileDeviceEnrollmentProfile, error)

GetMobileDeviceEnrollmentProfileByInvitationSubset finds a subset of data for an enrollment profile.

Required privileges: enrollment-profiles:read.

Parameters:

  • invitation: ID to filter by.
  • subset: Subset to filter by. Allowed values: "General", "Location", "Purchasing", "Attachments".

func (*Client) GetMobileDeviceEnrollmentProfileByName 

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

GetMobileDeviceEnrollmentProfileByName finds mobile device enrollment profiles by name.

Required privileges: enrollment-profiles:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetMobileDeviceEnrollmentProfileByNameSubset 

func (c *Client) GetMobileDeviceEnrollmentProfileByNameSubset(ctx context.Context, name string, subset string) (*MobileDeviceEnrollmentProfile, error)

GetMobileDeviceEnrollmentProfileByNameSubset finds a subset of data for mobile device enrollment profiles by name.

Required privileges: enrollment-profiles:read.

Parameters:

  • name: Name to filter by.
  • subset: Subset to filter by. Allowed values: "General", "Location", "Purchasing", "Attachments".

func (*Client) GetMobileDeviceExtensionAttributeByID 

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

GetMobileDeviceExtensionAttributeByID finds mobile device extension attributes by ID.

Required privileges: extension-attributes:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetMobileDeviceExtensionAttributeByName 

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

GetMobileDeviceExtensionAttributeByName finds mobiledeviceextensionattributes by name.

Required privileges: extension-attributes:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetMobileDeviceGroupByID 

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

GetMobileDeviceGroupByID finds mobile device groups by ID.

Required privileges: device-groups:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetMobileDeviceGroupByName 

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

GetMobileDeviceGroupByName finds mobile device groups by name.

Required privileges: device-groups:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetMobileDeviceHistoryByID 

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

GetMobileDeviceHistoryByID finds mobile device history by ID.

Required privileges: device-history:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetMobileDeviceHistoryByIDSubset 

func (c *Client) GetMobileDeviceHistoryByIDSubset(ctx context.Context, id string, subset string) (*MobileDeviceHistory, error)

GetMobileDeviceHistoryByIDSubset finds a subset of data for a mobile device history.

Required privileges: device-history:read.

Parameters:

  • id: ID to filter by.
  • subset: Subset to filter by. Allowed values: "General", "ManagementCommands", "UserLocation", "Audits", "Applications", "Ebooks".

func (*Client) GetMobileDeviceHistoryByMacAddress 

func (c *Client) GetMobileDeviceHistoryByMacAddress(ctx context.Context, macAddress string) (*MobileDeviceHistory, error)

GetMobileDeviceHistoryByMacAddress finds mobile device history by wifi mac address.

Required privileges: device-history:read.

Parameters:

  • macAddress: Mac address to filter by.

func (*Client) GetMobileDeviceHistoryByName 

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

GetMobileDeviceHistoryByName finds mobile device history by name.

Required privileges: device-history:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetMobileDeviceHistoryBySerialNumber 

func (c *Client) GetMobileDeviceHistoryBySerialNumber(ctx context.Context, serialNumber string) (*MobileDeviceHistory, error)

GetMobileDeviceHistoryBySerialNumber finds mobile device history by serial number.

Required privileges: device-history:read.

Parameters:

  • serialNumber: Serial number to filter by.

func (*Client) GetMobileDeviceHistoryByUDID 

func (c *Client) GetMobileDeviceHistoryByUDID(ctx context.Context, udid string) (*MobileDeviceHistory, error)

GetMobileDeviceHistoryByUDID finds mobile device history by UDID.

Required privileges: device-history:read.

Parameters:

  • udid: UDID to filter by.

func (*Client) GetMobileDeviceInvitationByID 

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

GetMobileDeviceInvitationByID finds mobile device invitations by id.

Required privileges: enrollment-invitations:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetMobileDeviceInvitationByInvitation 

func (c *Client) GetMobileDeviceInvitationByInvitation(ctx context.Context, invitation string) (*MobileDeviceInvitation, error)

GetMobileDeviceInvitationByInvitation finds mobile device invitations by invitation.

Required privileges: enrollment-invitations:read.

Parameters:

  • invitation: Invitation value to filter by.

func (*Client) GetMobileDeviceProvisioningProfileByID 

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

GetMobileDeviceProvisioningProfileByID finds a mobile device provisioning profiles by id.

Required privileges: provisioning-profiles:read.

Parameters:

  • id: Id value to filter by.

func (*Client) GetMobileDeviceProvisioningProfileByIDSubset 

func (c *Client) GetMobileDeviceProvisioningProfileByIDSubset(ctx context.Context, id string, subset string) (*MobileDeviceProvisioningProfile, error)

GetMobileDeviceProvisioningProfileByIDSubset finds a mobile device provisioning profiles by id.

Required privileges: provisioning-profiles:read.

Parameters:

  • id: Id value to filter by.
  • subset: Path parameter subset.

func (*Client) GetMobileDeviceProvisioningProfileByName 

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

GetMobileDeviceProvisioningProfileByName finds a mobile device provisioning profiles by name.

Required privileges: provisioning-profiles:read.

Parameters:

  • name: Name value to filter by.

func (*Client) GetMobileDeviceProvisioningProfileByUUID 

func (c *Client) GetMobileDeviceProvisioningProfileByUUID(ctx context.Context, uuid string) (*MobileDeviceProvisioningProfile, error)

GetMobileDeviceProvisioningProfileByUUID finds a mobile device provisioning profiles by uuid.

Required privileges: provisioning-profiles:read.

Parameters:

  • uuid: Uuid value to filter by.

func (*Client) GetNetworkSegmentByID 

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

GetNetworkSegmentByID finds network segments by ID.

Required privileges: network-segments:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetNetworkSegmentByName 

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

GetNetworkSegmentByName finds network segments by name.

Required privileges: network-segments:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetOSXConfigurationProfileByID 

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

GetOSXConfigurationProfileByID finds OS X configuration profiles by ID.

Required privileges: configuration-profiles:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetOSXConfigurationProfileByName 

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

GetOSXConfigurationProfileByName finds OS X configuration profiles by name.

Required privileges: configuration-profiles:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetOsxConfigurationProfileByIDSubset 

func (c *Client) GetOsxConfigurationProfileByIDSubset(ctx context.Context, id string, subset string) (*OsXConfigurationProfile, error)

GetOsxConfigurationProfileByIDSubset finds a subset of data for an OS X configuration profile.

Required privileges: configuration-profiles:read.

Parameters:

  • id: ID to filter by.
  • subset: Subset to filter by. Allowed values: "General", "Scope", "SelfService".

func (*Client) GetOsxConfigurationProfileByNameSubset 

func (c *Client) GetOsxConfigurationProfileByNameSubset(ctx context.Context, name string, subset string) (*OsXConfigurationProfile, error)

GetOsxConfigurationProfileByNameSubset finds a subset of data for OS X configuration profiles by name.

Required privileges: configuration-profiles:read.

Parameters:

  • name: Name to filter by.
  • subset: Subset to filter by. Allowed values: "General", "Scope", "SelfService".

func (*Client) GetPatchByID deprecated 

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

GetPatchByID finds patches by ID (Deprecated - Please transition use to Jamf Pro API endpoint "/v2/patch-software-title-configurations/{id}".).

Deprecated: this endpoint is marked deprecated in the Jamf API spec and may be removed in a future release.

Required privileges: patch-management-software-titles:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetPatchByIDVersion deprecated 

func (c *Client) GetPatchByIDVersion(ctx context.Context, id string, version string) (*SoftwareTitle, error)

GetPatchByIDVersion display computers on a specific version (Deprecated - Please transition use to Jamf Pro API endpoint "/v2/patch-software-title-configurations/{id}/definitions".).

Deprecated: this endpoint is marked deprecated in the Jamf API spec and may be removed in a future release.

Required privileges: patch-management-software-titles:read.

Parameters:

  • id: ID to filter by.
  • version: Version number to filter by.

func (*Client) GetPatchByName deprecated 

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

GetPatchByName finds the first patch with the name provided (Deprecated - Please transition use to Jamf Pro API endpoint "/v2/patch-software-title-configurations/{id}".).

Deprecated: this endpoint is marked deprecated in the Jamf API spec and may be removed in a future release.

Required privileges: patch-management-software-titles:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetPatchExternalSourceByID 

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

GetPatchExternalSourceByID finds a patch external source by ID.

Required privileges: patch-external-source:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetPatchExternalSourceByName 

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

GetPatchExternalSourceByName finds the first patch external source with the name provided.

Required privileges: patch-external-source:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetPatchInternalSourceByID 

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

GetPatchInternalSourceByID finds a patch internal source by ID.

Required privileges: patch-internal-source:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetPatchInternalSourceByName 

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

GetPatchInternalSourceByName finds the first patch internal source with the name provided.

Required privileges: patch-internal-source:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetPatchPolicyByID 

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

GetPatchPolicyByID finds a patch policy by ID.

Required privileges: patch-policies:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetPatchPolicyByIDSubset 

func (c *Client) GetPatchPolicyByIDSubset(ctx context.Context, id string, subset string) (*PatchPolicy, error)

GetPatchPolicyByIDSubset display subsets of information for a patch policy.

Required privileges: patch-policies:read.

Parameters:

  • id: ID to filter by.
  • subset: Subset to filter by. Allowed values: "General", "Scope", "UserInteraction".

func (*Client) GetPatchReportByPatchSoftwareTitleID deprecated 

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

GetPatchReportByPatchSoftwareTitleID finds patch reports by patch software title ID. (Deprecated) Please transition use to Jamf Pro API endpoint "/v2/patch-software-title-configurations/{id}/patch-report".

Deprecated: this endpoint is marked deprecated in the Jamf API spec and may be removed in a future release.

Required privileges: patch-management-software-titles:read.

Parameters:

  • id: Patch software title id to filter by.

func (*Client) GetPatchReportByTitleIDVersion deprecated 

func (c *Client) GetPatchReportByTitleIDVersion(ctx context.Context, id string, version string) (*PatchReport, error)

GetPatchReportByTitleIDVersion display computers for a specific version of a patch report. (Deprecated) Please transition use to Jamf Pro API endpoint "/v2/patch-software-title-configurations/{id}/patch-report".

Deprecated: this endpoint is marked deprecated in the Jamf API spec and may be removed in a future release.

Required privileges: patch-management-software-titles:read.

Parameters:

  • id: Patch software title ID to filter by.
  • version: Version number to filter by.

func (*Client) GetPatchSoftwareTitleByID deprecated 

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

GetPatchSoftwareTitleByID finds a patch software titles by ID. (Deprecated) Please transition use to Jamf Pro API endpoint "/v2/patch-software-title-configurations/{id}".

Deprecated: this endpoint is marked deprecated in the Jamf API spec and may be removed in a future release.

Required privileges: patch-management-software-titles:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetPolicyByCategory 

func (c *Client) GetPolicyByCategory(ctx context.Context, category string) (*Policy, error)

GetPolicyByCategory finds all policies by category.

Required privileges: policies:read.

Parameters:

  • category: Category to filter by.

func (*Client) GetPolicyByCreatedBy 

func (c *Client) GetPolicyByCreatedBy(ctx context.Context, createdBy string) (*Policy, error)

GetPolicyByCreatedBy finds all policies by type.

Required privileges: policies:read.

Parameters:

  • createdBy: Type to filter by. Allowed values: "jss", "casper".

func (*Client) GetPolicyByID 

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

GetPolicyByID finds policies by ID.

Required privileges: policies:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetPolicyByIDSubset 

func (c *Client) GetPolicyByIDSubset(ctx context.Context, id string, subset string) (*Policy, error)

GetPolicyByIDSubset finds a subset of data for a policy.

Required privileges: policies:read.

Parameters:

  • id: ID to filter by.
  • subset: Subset to filter by. Allowed values: "General", "Scope", "SelfService", "PackageConfiguration", "Scripts", "Printers", "DockItems", "AccountMaintenance", "Reboot", "Maintenance", "FilesProcesses", "UserInteraction", "DiskEncryption".

func (*Client) GetPolicyByName 

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

GetPolicyByName finds policies by name.

Required privileges: policies:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetPrinterByID 

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

GetPrinterByID finds printers by ID.

Required privileges: printers:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetPrinterByName 

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

GetPrinterByName finds printers by name.

Required privileges: printers:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetRemovableMacAddressByID 

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

GetRemovableMacAddressByID finds removable Mac addresses by ID.

Required privileges: removable-mac-address:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetRemovableMacAddressByName 

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

GetRemovableMacAddressByName finds removable Mac addresses by name.

Required privileges: removable-mac-address:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetRestrictedSoftwareByID 

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

GetRestrictedSoftwareByID finds restricted software by ID.

Required privileges: restricted-software:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetRestrictedSoftwareByName 

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

GetRestrictedSoftwareByName finds restricted software by name.

Required privileges: restricted-software:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetSMTPServer 

func (c *Client) GetSMTPServer(ctx context.Context) (*SmtpServer, error)

GetSMTPServer finds the Jamf Pro SMTP server information.

Required privileges: smtp-server:read.

func (*Client) GetSavedSearchByID deprecated 

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

GetSavedSearchByID finds saved searches by ID (Deprecated - use advancedcomputersearches, advancedmobiledevicesearches and advancedusersearches).

Deprecated: this endpoint is marked deprecated in the Jamf API spec and may be removed in a future release.

Required privileges: advanced-device-searches:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetSavedSearchByName deprecated 

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

GetSavedSearchByName finds saved searches by name (Deprecated - use advancedcomputersearches, advancedmobiledevicesearches and advancedusersearches).

Deprecated: this endpoint is marked deprecated in the Jamf API spec and may be removed in a future release.

Required privileges: advanced-device-searches:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetScriptByID 

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

GetScriptByID finds scripts by ID.

Required privileges: scripts:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetScriptByName 

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

GetScriptByName finds scripts by name.

Required privileges: scripts:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetSiteByID 

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

GetSiteByID finds sites by ID.

Required privileges: sites:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetSiteByName 

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

GetSiteByName finds sites by name.

Required privileges: sites:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetSoftwareUpdateServerByID 

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

GetSoftwareUpdateServerByID finds software update servers by ID.

Required privileges: software-update-servers:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetSoftwareUpdateServerByName 

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

GetSoftwareUpdateServerByName finds software update servers by name.

Required privileges: software-update-servers:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetUserByEmail 

func (c *Client) GetUserByEmail(ctx context.Context, email string) (*User, error)

GetUserByEmail finds users by email address.

Required privileges: users:read.

Parameters:

  • email: Email address to filter by.

func (*Client) GetUserByID 

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

GetUserByID finds users by ID.

Required privileges: users:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetUserByName 

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

GetUserByName finds users by name.

Required privileges: users:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetUserExtensionAttributeByID 

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

GetUserExtensionAttributeByID finds user extension attributes by ID.

Required privileges: user-extension-attributes:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetUserExtensionAttributeByName 

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

GetUserExtensionAttributeByName finds user extension attributes by name.

Required privileges: user-extension-attributes:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetUserGroupByID 

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

GetUserGroupByID finds user groups by ID.

Required privileges: user-groups:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetUserGroupByName 

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

GetUserGroupByName finds user groups by name.

Required privileges: user-groups:read.

Parameters:

  • name: Name to filter by.

func (*Client) GetVPPAccountByID 

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

GetVPPAccountByID finds VPP Account by ID.

Required privileges: volume-purchasing-locations:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetVPPAssignmentByID 

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

GetVPPAssignmentByID finds VPP Assignment by ID.

Required privileges: volume-purchasing-locations:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetVPPInvitationByID 

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

GetVPPInvitationByID finds a VPP Invitation by ID.

Required privileges: volume-purchasing-locations:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetVPPInvitationByIDSubset 

func (c *Client) GetVPPInvitationByIDSubset(ctx context.Context, id string, subset string) (*VppInvitation, error)

GetVPPInvitationByIDSubset finds a subset of data for a VPP invitation.

Required privileges: volume-purchasing-locations:read.

Parameters:

  • id: ID to filter by.
  • subset: Subset to filter by. Allowed values: "General", "Scope", "InvitationUsages".

func (*Client) GetWebhookByID 

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

GetWebhookByID finds webhooks by ID.

Required privileges: webhooks:read.

Parameters:

  • id: ID value to filter by.

func (*Client) GetWebhookByName 

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

GetWebhookByName finds webhooks by name.

Required privileges: webhooks:read.

Parameters:

  • name: Name to filter by.

func (*Client) IssueComputerCommandByID 

func (c *Client) IssueComputerCommandByID(ctx context.Context, command string, id string, request *ComputerCommandPost) (*ComputerCommand, error)

IssueComputerCommandByID creates a new computer command using command name and device IDs.

Required privileges: destructive-device-actions:execute.

Parameters:

  • command: Command to send (EnableRemoteDesktop and DisableRemoteDesktop require macOS 10.14.4). Allowed values: "EnableRemoteDesktop", "DisableRemoteDesktop".
  • id: Computer ID - supports comma separated values (e.g. id/8,10,55).

func (*Client) IssueMobileDeviceCommand 

func (c *Client) IssueMobileDeviceCommand(ctx context.Context, request *MobileDeviceCommandPost) (*MobileDeviceCommand, error)

IssueMobileDeviceCommand creates a new mobile device command.

Required privileges: destructive-device-actions:execute, devices:create. All of them are required, not alternatives.

func (*Client) ListAccounts 

func (c *Client) ListAccounts(ctx context.Context) (*Accounts, error)

ListAccounts finds all accounts.

Required privileges: accounts:read.

func (*Client) ListAdvancedComputerSearches 

func (c *Client) ListAdvancedComputerSearches(ctx context.Context) (*AdvancedComputerSearches, error)

ListAdvancedComputerSearches finds all advanced computer searches.

Required privileges: advanced-device-searches:read.

func (*Client) ListAdvancedMobileDeviceSearches 

func (c *Client) ListAdvancedMobileDeviceSearches(ctx context.Context) (*AdvancedMobileDeviceSearches, error)

ListAdvancedMobileDeviceSearches finds all advanced mobile device searches.

Required privileges: advanced-device-searches:read.

func (*Client) ListAdvancedUserSearches 

func (c *Client) ListAdvancedUserSearches(ctx context.Context) (*AdvancedUserSearches, error)

ListAdvancedUserSearches finds all advanced user searches.

Required privileges: advanced-user-searches:read.

func (*Client) ListAllowedFileExtensions 

func (c *Client) ListAllowedFileExtensions(ctx context.Context) (*AllowedFileExtensions, error)

ListAllowedFileExtensions finds the allowed file extensions.

Required privileges: allowed-file-extension:read.

func (*Client) ListBuildings 

func (c *Client) ListBuildings(ctx context.Context) (*Buildings, error)

ListBuildings finds all buildings.

Required privileges: buildings:read.

func (*Client) ListCategories 

func (c *Client) ListCategories(ctx context.Context) (*Categories, error)

ListCategories finds all categories.

Required privileges: categories:read.

func (*Client) ListClasses 

func (c *Client) ListClasses(ctx context.Context) (*Classes, error)

ListClasses finds all classes.

Required privileges: classes:read.

func (*Client) ListClassicPackages 

func (c *Client) ListClassicPackages(ctx context.Context) (*Packages, error)

ListClassicPackages finds all packages.

Required privileges: packages:read.

func (*Client) ListComputerCommands 

func (c *Client) ListComputerCommands(ctx context.Context) (*ComputerCommands, error)

ListComputerCommands finds all computer commands.

Required privileges: device-actions:read.

func (*Client) ListComputerExtensionAttributes 

func (c *Client) ListComputerExtensionAttributes(ctx context.Context) (*ComputerExtensionAttributes, error)

ListComputerExtensionAttributes finds all computer extension attributes.

Required privileges: extension-attributes:read.

func (*Client) ListComputerGroups 

func (c *Client) ListComputerGroups(ctx context.Context) (*ComputerGroups, error)

ListComputerGroups finds all computer groups.

Required privileges: device-groups:read.

func (*Client) ListComputerInvitations 

func (c *Client) ListComputerInvitations(ctx context.Context) (*ComputerInvitations, error)

ListComputerInvitations finds all computer invitations.

Required privileges: enrollment-invitations:read.

func (*Client) ListComputerReports 

func (c *Client) ListComputerReports(ctx context.Context) (*ComputerReports, error)

ListComputerReports finds all computer reports.

Required privileges: device-history:read.

func (*Client) ListDepartments 

func (c *Client) ListDepartments(ctx context.Context) (*Departments, error)

ListDepartments finds all departments.

Required privileges: departments:read.

func (*Client) ListDirectoryBindings 

func (c *Client) ListDirectoryBindings(ctx context.Context) (*DirectoryBindings, error)

ListDirectoryBindings finds all directory bindings.

Required privileges: directory-bindings:read.

func (*Client) ListDiskEncryptionConfigurations 

func (c *Client) ListDiskEncryptionConfigurations(ctx context.Context) (*DiskEncryptionConfigurations, error)

ListDiskEncryptionConfigurations finds all disk encryption configurations.

Required privileges: disk-encryption-configurations:read.

func (*Client) ListDistributionPoints 

func (c *Client) ListDistributionPoints(ctx context.Context) (*DistributionPoints, error)

ListDistributionPoints finds all distribution points.

Required privileges: distribution-points:read.

func (*Client) ListDockItems 

func (c *Client) ListDockItems(ctx context.Context) (*DockItems, error)

ListDockItems finds all dock items.

Required privileges: dock-items:read.

func (*Client) ListEbooks 

func (c *Client) ListEbooks(ctx context.Context) (*Ebooks, error)

ListEbooks finds all ebooks.

Required privileges: ebooks:read.

func (*Client) ListHealthcareListenerRules 

func (c *Client) ListHealthcareListenerRules(ctx context.Context) (*HealthcareListenerRules, error)

ListHealthcareListenerRules find all Healthcare Listener rules.

Required privileges: infrastructure-managers:read.

func (*Client) ListHealthcareListeners 

func (c *Client) ListHealthcareListeners(ctx context.Context) (*HealthcareListeners, error)

ListHealthcareListeners find all Healthcare Listeners.

Required privileges: infrastructure-managers:read.

func (*Client) ListIBeacons 

func (c *Client) ListIBeacons(ctx context.Context) (*Ibeacons, error)

ListIBeacons finds all iBeacon regions.

Required privileges: ibeacon:read.

func (*Client) ListInfrastructureManagers 

func (c *Client) ListInfrastructureManagers(ctx context.Context) (*InfrastructureManagers, error)

ListInfrastructureManagers find all Infrastructure Managers.

Required privileges: infrastructure-managers:read.

func (*Client) ListJsonWebTokenConfigurations 

func (c *Client) ListJsonWebTokenConfigurations(ctx context.Context) (*JsonWebTokenConfigurations, error)

ListJsonWebTokenConfigurations finds all JSON Web Token configurations.

Required privileges: json-web-token-configuration:read.

func (*Client) ListLDAPServers 

func (c *Client) ListLDAPServers(ctx context.Context) (*LdapServers, error)

ListLDAPServers finds all LDAP servers.

Required privileges: ldap-servers:read.

func (*Client) ListLicensedSoftware 

func (c *Client) ListLicensedSoftware(ctx context.Context) (*LicensedSoftwareAll, error)

ListLicensedSoftware finds all licensed software.

Required privileges: licensed-software:read.

func (*Client) ListMacApplications 

func (c *Client) ListMacApplications(ctx context.Context) (*MacApplications, error)

ListMacApplications finds all mac applications.

Required privileges: applications:read.

func (*Client) ListMobileDeviceApplications 

func (c *Client) ListMobileDeviceApplications(ctx context.Context) (*MobileDeviceApplications, error)

ListMobileDeviceApplications finds all mobile device applications.

Required privileges: applications:read.

func (*Client) ListMobileDeviceCommands 

func (c *Client) ListMobileDeviceCommands(ctx context.Context) (*MobileDeviceCommands, error)

ListMobileDeviceCommands finds all mobile device commands.

Required privileges: device-actions:read.

func (*Client) ListMobileDeviceConfigurationProfiles 

func (c *Client) ListMobileDeviceConfigurationProfiles(ctx context.Context) (*MobileDeviceConfigurationProfiles, error)

ListMobileDeviceConfigurationProfiles finds all mobile device configuration profiles.

Required privileges: configuration-profiles:read.

func (*Client) ListMobileDeviceEnrollmentProfiles 

func (c *Client) ListMobileDeviceEnrollmentProfiles(ctx context.Context) (*MobileDeviceEnrollmentProfiles, error)

ListMobileDeviceEnrollmentProfiles finds all mobile device enrollment profiles.

Required privileges: enrollment-profiles:read.

func (*Client) ListMobileDeviceExtensionAttributes 

func (c *Client) ListMobileDeviceExtensionAttributes(ctx context.Context) (*MobileDeviceExtensionAttributes, error)

ListMobileDeviceExtensionAttributes finds all mobile device extension attributes.

Required privileges: extension-attributes:read.

func (*Client) ListMobileDeviceGroups 

func (c *Client) ListMobileDeviceGroups(ctx context.Context) (*MobileDeviceGroups, error)

ListMobileDeviceGroups finds all mobile device groups.

Required privileges: device-groups:read.

func (*Client) ListMobileDeviceInvitations 

func (c *Client) ListMobileDeviceInvitations(ctx context.Context) (*MobileDeviceInvitations, error)

ListMobileDeviceInvitations finds all mobile device invitations.

Required privileges: enrollment-invitations:read.

func (*Client) ListMobileDeviceProvisioningProfiles 

func (c *Client) ListMobileDeviceProvisioningProfiles(ctx context.Context) (*MobileDeviceProvisioningProfiles, error)

ListMobileDeviceProvisioningProfiles finds all mobile device provisioning profiles.

Required privileges: provisioning-profiles:read.

func (*Client) ListMobileDevices 

func (c *Client) ListMobileDevices(ctx context.Context) (*MobileDevices, error)

ListMobileDevices finds all mobile devices.

Required privileges: devices:read.

func (*Client) ListNetworkSegments 

func (c *Client) ListNetworkSegments(ctx context.Context) (*NetworkSegments, error)

ListNetworkSegments finds all network segments.

Required privileges: network-segments:read.

func (*Client) ListOSXConfigurationProfiles 

func (c *Client) ListOSXConfigurationProfiles(ctx context.Context) (*OsXConfigurationProfiles, error)

ListOSXConfigurationProfiles finds all OS X configuration profiles.

Required privileges: configuration-profiles:read.

func (*Client) ListPatchAvailableTitlesBySourceID 

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

ListPatchAvailableTitlesBySourceID finds all available title from a source by ID.

Required privileges: patch-management-software-titles:read.

Parameters:

  • id: ID of the internal or external patch source to filter by.

func (*Client) ListPatchExternalSources 

func (c *Client) ListPatchExternalSources(ctx context.Context) (*PatchExternalSources, error)

ListPatchExternalSources finds all patch external sources.

Required privileges: patch-external-source:read.

func (*Client) ListPatchInternalSources 

func (c *Client) ListPatchInternalSources(ctx context.Context) (*PatchInternalSources, error)

ListPatchInternalSources finds all patch internal sources.

Required privileges: patch-internal-source:read.

func (*Client) ListPatchPolicies deprecated 

func (c *Client) ListPatchPolicies(ctx context.Context) (*PatchPolicies, error)

ListPatchPolicies finds all patch policies. (Deprecated). Please transition use to Jamf Pro API endpoint "/v2/patch-policies".

Deprecated: this endpoint is marked deprecated in the Jamf API spec and may be removed in a future release.

Required privileges: patch-policies:read.

func (*Client) ListPatchPoliciesBySoftwareTitleConfigID deprecated 

func (c *Client) ListPatchPoliciesBySoftwareTitleConfigID(ctx context.Context, softwareTitleConfigID string) (*PatchPolicies, error)

ListPatchPoliciesBySoftwareTitleConfigID finds all patch policies by patch software title configuration ID (Deprecated). Please transition use to Jamf Pro API endpoint "/v2/patch-policies".

Deprecated: this endpoint is marked deprecated in the Jamf API spec and may be removed in a future release.

Required privileges: patch-policies:read.

Parameters:

  • softwareTitleConfigID: Patch software title config ID value to filter by.

func (*Client) ListPatchSoftwareTitles deprecated 

func (c *Client) ListPatchSoftwareTitles(ctx context.Context) (*PatchSoftwareTitles, error)

ListPatchSoftwareTitles finds all patch software titles. (Deprecated) Please transition use to Jamf Pro API endpoint "/v2/patch-software-title-configurations".

Deprecated: this endpoint is marked deprecated in the Jamf API spec and may be removed in a future release.

Required privileges: patch-management-software-titles:read.

func (*Client) ListPatches deprecated 

func (c *Client) ListPatches(ctx context.Context) (*PatchManagementSoftwareTitles, error)

ListPatches finds all patches (Deprecated - Please transition use to Jamf Pro API endpoint "/v2/patch-software-title-configurations".

Deprecated: this endpoint is marked deprecated in the Jamf API spec and may be removed in a future release.

Required privileges: patch-management-software-titles:read.

func (*Client) ListPolicies 

func (c *Client) ListPolicies(ctx context.Context) (*Policies, error)

ListPolicies finds all policies.

Required privileges: policies:read.

func (*Client) ListPrinters 

func (c *Client) ListPrinters(ctx context.Context) (*Printers, error)

ListPrinters finds all printers.

Required privileges: printers:read.

func (*Client) ListRemovableMacAddresses 

func (c *Client) ListRemovableMacAddresses(ctx context.Context) (*RemovableMacAddresses, error)

ListRemovableMacAddresses finds all removable Mac addresses.

Required privileges: removable-mac-address:read.

func (*Client) ListRestrictedSoftware 

func (c *Client) ListRestrictedSoftware(ctx context.Context) (*RestrictedSoftwareAll, error)

ListRestrictedSoftware finds all restricted software.

Required privileges: restricted-software:read.

func (*Client) ListSavedSearches deprecated 

func (c *Client) ListSavedSearches(ctx context.Context) (*SavedSearches, error)

ListSavedSearches finds all saved searches (Deprecated - use advancedcomputersearches, advancedmobiledevicesearches and advancedusersearches).

Deprecated: this endpoint is marked deprecated in the Jamf API spec and may be removed in a future release.

Required privileges: advanced-device-searches:read.

func (*Client) ListScripts 

func (c *Client) ListScripts(ctx context.Context) (*Scripts, error)

ListScripts finds all scripts.

Required privileges: scripts:read.

func (*Client) ListSites 

func (c *Client) ListSites(ctx context.Context) (*Sites, error)

ListSites finds all sites.

Required privileges: sites:read.

func (*Client) ListSoftwareUpdateServers 

func (c *Client) ListSoftwareUpdateServers(ctx context.Context) (*SoftwareUpdateServers, error)

ListSoftwareUpdateServers finds all software update servers.

Required privileges: software-update-servers:read.

func (*Client) ListUserExtensionAttributes 

func (c *Client) ListUserExtensionAttributes(ctx context.Context) (*UserExtensionAttributes, error)

ListUserExtensionAttributes finds all user extension attributes.

Required privileges: user-extension-attributes:read.

func (*Client) ListUserGroups 

func (c *Client) ListUserGroups(ctx context.Context) (*UserGroups, error)

ListUserGroups finds all user groups.

Required privileges: user-groups:read.

func (*Client) ListUsers 

func (c *Client) ListUsers(ctx context.Context) (*Users, error)

ListUsers finds all users.

Required privileges: users:read.

func (*Client) ListVPPAccounts 

func (c *Client) ListVPPAccounts(ctx context.Context) (*VppAccounts, error)

ListVPPAccounts finds all VPP Accounts.

Required privileges: volume-purchasing-locations:read.

func (*Client) ListVPPAssignments 

func (c *Client) ListVPPAssignments(ctx context.Context) (*VppAssignments, error)

ListVPPAssignments finds all VPP Assignments.

Required privileges: volume-purchasing-locations:read.

func (*Client) ListVPPInvitations 

func (c *Client) ListVPPInvitations(ctx context.Context) (*VppInvitations, error)

ListVPPInvitations finds all VPP Invitations.

Required privileges: volume-purchasing-locations:read.

func (*Client) ListWebhooks 

func (c *Client) ListWebhooks(ctx context.Context) (*Webhooks, error)

ListWebhooks finds all webhooks.

Required privileges: webhooks:read.

func (*Client) MatchComputers deprecated 

func (c *Client) MatchComputers(ctx context.Context, match string) (*Computers, error)

MatchComputers searches for computers that match the provided parameter.

Deprecated: this endpoint is marked deprecated in the Jamf API spec (deprecation-date: 2025-02-11) and may be removed in a future release.

Required privileges: devices:read.

Parameters:

  • match: Name, mac address, etc. to filter by. Match uses the same format as the general search in Jamf Pro. For instance, admin* can be used to match computer names that begin with admin.

func (*Client) MatchComputersByName deprecated 

func (c *Client) MatchComputersByName(ctx context.Context, matchName string) (*Computers, error)

MatchComputersByName searches for computers that match the provided name parameter.

Deprecated: this endpoint is marked deprecated in the Jamf API spec (deprecation-date: 2025-02-11) and may be removed in a future release.

Required privileges: devices:read.

Parameters:

  • matchName: Name to filter by.

func (*Client) ResolveAccountGroupByName 

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

ResolveAccountGroupByName looks up a AccountGroup by name. Alias for GetAccountGroupByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveAccountGroupIDByName 

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

ResolveAccountGroupIDByName looks up a AccountGroup by name via GetAccountGroupByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveAdvancedComputerSearchByName 

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

ResolveAdvancedComputerSearchByName looks up a AdvancedComputerSearch by name. Alias for GetAdvancedComputerSearchByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveAdvancedComputerSearchIDByName 

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

ResolveAdvancedComputerSearchIDByName looks up a AdvancedComputerSearch by name via GetAdvancedComputerSearchByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveAdvancedMobileDeviceSearchByName 

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

ResolveAdvancedMobileDeviceSearchByName looks up a AdvancedMobileDeviceSearch by name. Alias for GetAdvancedMobileDeviceSearchByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveAdvancedMobileDeviceSearchIDByName 

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

ResolveAdvancedMobileDeviceSearchIDByName looks up a AdvancedMobileDeviceSearch by name via GetAdvancedMobileDeviceSearchByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveAdvancedUserSearchByName 

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

ResolveAdvancedUserSearchByName looks up a AdvancedUserSearch by name. Alias for GetAdvancedUserSearchByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveAdvancedUserSearchIDByName 

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

ResolveAdvancedUserSearchIDByName looks up a AdvancedUserSearch by name via GetAdvancedUserSearchByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveBuildingByName 

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

ResolveBuildingByName looks up a Building by name. Alias for GetBuildingByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveBuildingIDByName 

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

ResolveBuildingIDByName looks up a Building by name via GetBuildingByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveCategoryByName 

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

ResolveCategoryByName looks up a Category by name. Alias for GetCategoryByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveCategoryIDByName 

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

ResolveCategoryIDByName looks up a Category by name via GetCategoryByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveClassByName 

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

ResolveClassByName looks up a Class by name. Alias for GetClassByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveClassIDByName 

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

ResolveClassIDByName looks up a Class by name via GetClassByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveClassicPackageByName 

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

ResolveClassicPackageByName looks up a ClassicPackage by name. Alias for GetClassicPackageByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveClassicPackageIDByName 

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

ResolveClassicPackageIDByName looks up a ClassicPackage by name via GetClassicPackageByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveComputerExtensionAttributeByName 

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

ResolveComputerExtensionAttributeByName looks up a ComputerExtensionAttribute by name. Alias for GetComputerExtensionAttributeByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveComputerExtensionAttributeIDByName 

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

ResolveComputerExtensionAttributeIDByName looks up a ComputerExtensionAttribute by name via GetComputerExtensionAttributeByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveComputerGroupByName 

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

ResolveComputerGroupByName looks up a ComputerGroup by name. Alias for GetComputerGroupByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveComputerGroupIDByName 

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

ResolveComputerGroupIDByName looks up a ComputerGroup by name via GetComputerGroupByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveDepartmentByName 

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

ResolveDepartmentByName looks up a Department by name. Alias for GetDepartmentByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveDepartmentIDByName 

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

ResolveDepartmentIDByName looks up a Department by name via GetDepartmentByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveDirectoryBindingByName 

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

ResolveDirectoryBindingByName looks up a DirectoryBinding by name. Alias for GetDirectoryBindingByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveDirectoryBindingIDByName 

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

ResolveDirectoryBindingIDByName looks up a DirectoryBinding by name via GetDirectoryBindingByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveDiskEncryptionConfigurationByName 

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

ResolveDiskEncryptionConfigurationByName looks up a DiskEncryptionConfiguration by name. Alias for GetDiskEncryptionConfigurationByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveDiskEncryptionConfigurationIDByName 

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

ResolveDiskEncryptionConfigurationIDByName looks up a DiskEncryptionConfiguration by name via GetDiskEncryptionConfigurationByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveDistributionPointByName 

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

ResolveDistributionPointByName looks up a DistributionPoint by name. Alias for GetDistributionPointByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveDistributionPointIDByName 

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

ResolveDistributionPointIDByName looks up a DistributionPoint by name via GetDistributionPointByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveDockItemByName 

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

ResolveDockItemByName looks up a DockItem by name. Alias for GetDockItemByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveDockItemIDByName 

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

ResolveDockItemIDByName looks up a DockItem by name via GetDockItemByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveEbookByName 

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

ResolveEbookByName looks up a Ebook by name. Alias for GetEbookByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveEbookIDByName 

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

ResolveEbookIDByName looks up a Ebook by name via GetEbookByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveIBeaconByName 

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

ResolveIBeaconByName looks up a IBeacon by name. Alias for GetIBeaconByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveIBeaconIDByName 

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

ResolveIBeaconIDByName looks up a IBeacon by name via GetIBeaconByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveLDAPServerByName 

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

ResolveLDAPServerByName looks up a LDAPServer by name. Alias for GetLDAPServerByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveLDAPServerIDByName 

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

ResolveLDAPServerIDByName looks up a LDAPServer by name via GetLDAPServerByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveLicensedSoftwareByName 

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

ResolveLicensedSoftwareByName looks up a LicensedSoftware by name. Alias for GetLicensedSoftwareByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveLicensedSoftwareIDByName 

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

ResolveLicensedSoftwareIDByName looks up a LicensedSoftware by name via GetLicensedSoftwareByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveMacApplicationByName 

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

ResolveMacApplicationByName looks up a MacApplication by name. Alias for GetMacApplicationByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveMacApplicationIDByName 

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

ResolveMacApplicationIDByName looks up a MacApplication by name via GetMacApplicationByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveMobileDeviceApplicationByName 

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

ResolveMobileDeviceApplicationByName looks up a MobileDeviceApplication by name. Alias for GetMobileDeviceApplicationByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveMobileDeviceApplicationIDByName 

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

ResolveMobileDeviceApplicationIDByName looks up a MobileDeviceApplication by name via GetMobileDeviceApplicationByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveMobileDeviceConfigurationProfileByName 

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

ResolveMobileDeviceConfigurationProfileByName looks up a MobileDeviceConfigurationProfile by name. Alias for GetMobileDeviceConfigurationProfileByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveMobileDeviceConfigurationProfileIDByName 

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

ResolveMobileDeviceConfigurationProfileIDByName looks up a MobileDeviceConfigurationProfile by name via GetMobileDeviceConfigurationProfileByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveMobileDeviceEnrollmentProfileByName 

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

ResolveMobileDeviceEnrollmentProfileByName looks up a MobileDeviceEnrollmentProfile by name. Alias for GetMobileDeviceEnrollmentProfileByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveMobileDeviceEnrollmentProfileIDByName 

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

ResolveMobileDeviceEnrollmentProfileIDByName looks up a MobileDeviceEnrollmentProfile by name via GetMobileDeviceEnrollmentProfileByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveMobileDeviceExtensionAttributeByName 

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

ResolveMobileDeviceExtensionAttributeByName looks up a MobileDeviceExtensionAttribute by name. Alias for GetMobileDeviceExtensionAttributeByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveMobileDeviceExtensionAttributeIDByName 

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

ResolveMobileDeviceExtensionAttributeIDByName looks up a MobileDeviceExtensionAttribute by name via GetMobileDeviceExtensionAttributeByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveMobileDeviceGroupByName 

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

ResolveMobileDeviceGroupByName looks up a MobileDeviceGroup by name. Alias for GetMobileDeviceGroupByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveMobileDeviceGroupIDByName 

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

ResolveMobileDeviceGroupIDByName looks up a MobileDeviceGroup by name via GetMobileDeviceGroupByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveMobileDeviceProvisioningProfileByName 

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

ResolveMobileDeviceProvisioningProfileByName looks up a MobileDeviceProvisioningProfile by name. Alias for GetMobileDeviceProvisioningProfileByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveMobileDeviceProvisioningProfileIDByName 

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

ResolveMobileDeviceProvisioningProfileIDByName looks up a MobileDeviceProvisioningProfile by name via GetMobileDeviceProvisioningProfileByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveNetworkSegmentByName 

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

ResolveNetworkSegmentByName looks up a NetworkSegment by name. Alias for GetNetworkSegmentByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveNetworkSegmentIDByName 

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

ResolveNetworkSegmentIDByName looks up a NetworkSegment by name via GetNetworkSegmentByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveOSXConfigurationProfileByName 

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

ResolveOSXConfigurationProfileByName looks up a OSXConfigurationProfile by name. Alias for GetOSXConfigurationProfileByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveOSXConfigurationProfileIDByName 

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

ResolveOSXConfigurationProfileIDByName looks up a OSXConfigurationProfile by name via GetOSXConfigurationProfileByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolvePatchExternalSourceByName 

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

ResolvePatchExternalSourceByName looks up a PatchExternalSource by name. Alias for GetPatchExternalSourceByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolvePatchExternalSourceIDByName 

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

ResolvePatchExternalSourceIDByName looks up a PatchExternalSource by name via GetPatchExternalSourceByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolvePatchInternalSourceByName 

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

ResolvePatchInternalSourceByName looks up a PatchInternalSource by name. Alias for GetPatchInternalSourceByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolvePatchInternalSourceIDByName 

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

ResolvePatchInternalSourceIDByName looks up a PatchInternalSource by name via GetPatchInternalSourceByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolvePolicyByName 

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

ResolvePolicyByName looks up a Policy by name. Alias for GetPolicyByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolvePolicyIDByName 

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

ResolvePolicyIDByName looks up a Policy by name via GetPolicyByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolvePrinterByName 

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

ResolvePrinterByName looks up a Printer by name. Alias for GetPrinterByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolvePrinterIDByName 

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

ResolvePrinterIDByName looks up a Printer by name via GetPrinterByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveRemovableMacAddressByName 

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

ResolveRemovableMacAddressByName looks up a RemovableMacAddress by name. Alias for GetRemovableMacAddressByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveRemovableMacAddressIDByName 

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

ResolveRemovableMacAddressIDByName looks up a RemovableMacAddress by name via GetRemovableMacAddressByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveRestrictedSoftwareByName 

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

ResolveRestrictedSoftwareByName looks up a RestrictedSoftware by name. Alias for GetRestrictedSoftwareByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveRestrictedSoftwareIDByName 

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

ResolveRestrictedSoftwareIDByName looks up a RestrictedSoftware by name via GetRestrictedSoftwareByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveScriptByName 

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

ResolveScriptByName looks up a Script by name. Alias for GetScriptByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveScriptIDByName 

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

ResolveScriptIDByName looks up a Script by name via GetScriptByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveSiteByName 

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

ResolveSiteByName looks up a Site by name. Alias for GetSiteByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveSiteIDByName 

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

ResolveSiteIDByName looks up a Site by name via GetSiteByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveSoftwareUpdateServerByName 

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

ResolveSoftwareUpdateServerByName looks up a SoftwareUpdateServer by name. Alias for GetSoftwareUpdateServerByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveSoftwareUpdateServerIDByName 

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

ResolveSoftwareUpdateServerIDByName looks up a SoftwareUpdateServer by name via GetSoftwareUpdateServerByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveUserByName 

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

ResolveUserByName looks up a User by name. Alias for GetUserByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveUserExtensionAttributeByName 

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

ResolveUserExtensionAttributeByName looks up a UserExtensionAttribute by name. Alias for GetUserExtensionAttributeByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveUserExtensionAttributeIDByName 

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

ResolveUserExtensionAttributeIDByName looks up a UserExtensionAttribute by name via GetUserExtensionAttributeByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveUserGroupByName 

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

ResolveUserGroupByName looks up a UserGroup by name. Alias for GetUserGroupByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveUserGroupIDByName 

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

ResolveUserGroupIDByName looks up a UserGroup by name via GetUserGroupByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveUserIDByName 

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

ResolveUserIDByName looks up a User by name via GetUserByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) ResolveWebhookByName 

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

ResolveWebhookByName looks up a Webhook by name. Alias for GetWebhookByName; present so callers can use the same Resolve<X>ByName spelling across all resources regardless of resolver mode.

func (*Client) ResolveWebhookIDByName 

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

ResolveWebhookIDByName looks up a Webhook by name via GetWebhookByName and returns its ID as a string. Returns an error when the underlying call returns a nil ID.

func (*Client) UpdateAccountByUserID 

func (c *Client) UpdateAccountByUserID(ctx context.Context, id string, request *Account) error

UpdateAccountByUserID updates an existing account by ID.

Required privileges: accounts:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateAccountByUsername 

func (c *Client) UpdateAccountByUsername(ctx context.Context, name string, request *Account) error

UpdateAccountByUsername updates an existing account by name.

Required privileges: accounts:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateAccountGroupByID 

func (c *Client) UpdateAccountGroupByID(ctx context.Context, id string, request *Group) error

UpdateAccountGroupByID updates an existing group by ID.

Required privileges: accounts:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateAccountGroupByName 

func (c *Client) UpdateAccountGroupByName(ctx context.Context, name string, request *Group) error

UpdateAccountGroupByName updates an existing group by name.

Required privileges: accounts:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateActivationCode deprecated 

func (c *Client) UpdateActivationCode(ctx context.Context, request *ActivationCode) error

UpdateActivationCode updates the Jamf Pro activation code.

Deprecated: this endpoint is marked deprecated in the Jamf API spec (deprecation-date: 2026-07-14) and may be removed in a future release.

Required privileges: activation-code:update.

Use `pro.UpdateActivationCodeV1` instead. The deprecation above names no successor; that is the one, and unlike the read half it is published and routed today.

func (*Client) UpdateAdvancedComputerSearchByID 

func (c *Client) UpdateAdvancedComputerSearchByID(ctx context.Context, id string, request *AdvancedComputerSearch) error

UpdateAdvancedComputerSearchByID updates an existing advanced computer search by ID.

Required privileges: advanced-device-searches:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateAdvancedComputerSearchByName 

func (c *Client) UpdateAdvancedComputerSearchByName(ctx context.Context, name string, request *AdvancedComputerSearch) error

UpdateAdvancedComputerSearchByName updates an existing advanced computer search by name.

Required privileges: advanced-device-searches:update.

Parameters:

  • name: Name to filter by.

func (*Client) UpdateAdvancedMobileDeviceSearchByID 

func (c *Client) UpdateAdvancedMobileDeviceSearchByID(ctx context.Context, id string, request *AdvancedMobileDeviceSearch) error

UpdateAdvancedMobileDeviceSearchByID updates an existing advanced mobile device search by ID.

Required privileges: advanced-device-searches:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateAdvancedMobileDeviceSearchByName 

func (c *Client) UpdateAdvancedMobileDeviceSearchByName(ctx context.Context, name string, request *AdvancedMobileDeviceSearch) error

UpdateAdvancedMobileDeviceSearchByName updates an existing advanced mobile device search by name.

Required privileges: advanced-device-searches:update.

Parameters:

  • name: Nameto filter by.

func (*Client) UpdateAdvancedUserSearchByID 

func (c *Client) UpdateAdvancedUserSearchByID(ctx context.Context, id string, request *AdvancedUserSearch) error

UpdateAdvancedUserSearchByID updates an existing advanced user search by ID.

Required privileges: advanced-user-searches:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateAdvancedUserSearchByName 

func (c *Client) UpdateAdvancedUserSearchByName(ctx context.Context, name string, request *AdvancedUserSearch) error

UpdateAdvancedUserSearchByName updates an existing advanced user search by name.

Required privileges: advanced-user-searches:update.

Parameters:

  • name: Name to filter by.

func (*Client) UpdateBuildingByID 

func (c *Client) UpdateBuildingByID(ctx context.Context, id string, request *Building) error

UpdateBuildingByID updates an existing building by ID.

Required privileges: buildings:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateBuildingByName 

func (c *Client) UpdateBuildingByName(ctx context.Context, name string, request *Building) error

UpdateBuildingByName updates an existing building by name.

Required privileges: buildings:update.

Parameters:

  • name: Name to filter by.

func (*Client) UpdateCategoryByID 

func (c *Client) UpdateCategoryByID(ctx context.Context, id string, request *Category) error

UpdateCategoryByID updates an existing category by ID.

Required privileges: categories:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateCategoryByName 

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

UpdateCategoryByName updates an existing category by name.

Required privileges: categories:update.

Parameters:

  • name: Name to filter by.

func (*Client) UpdateClassByID 

func (c *Client) UpdateClassByID(ctx context.Context, id string, request *ClassPost) error

UpdateClassByID updates an existing class by ID.

Required privileges: classes:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateClassByName 

func (c *Client) UpdateClassByName(ctx context.Context, name string, request *ClassPost) error

UpdateClassByName updates an existing class by name.

Required privileges: classes:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateClassicPackageByID 

func (c *Client) UpdateClassicPackageByID(ctx context.Context, id string, request *Package) error

UpdateClassicPackageByID updates an existing package by ID.

Required privileges: packages:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateClassicPackageByName 

func (c *Client) UpdateClassicPackageByName(ctx context.Context, name string, request *Package) error

UpdateClassicPackageByName updates an existing package by name.

Required privileges: packages:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateComputerCheckIn 

func (c *Client) UpdateComputerCheckIn(ctx context.Context, request *ComputerCheckIn) error

UpdateComputerCheckIn updates the Jamf Pro computer checkin information.

Required privileges: computer-check-in:update.

func (*Client) UpdateComputerExtensionAttributeByID 

func (c *Client) UpdateComputerExtensionAttributeByID(ctx context.Context, id string, request *ComputerExtensionAttribute) error

UpdateComputerExtensionAttributeByID updates an existing computer extension attribute by ID.

Required privileges: extension-attributes:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateComputerExtensionAttributeByName 

func (c *Client) UpdateComputerExtensionAttributeByName(ctx context.Context, name string, request *ComputerExtensionAttribute) error

UpdateComputerExtensionAttributeByName updates an existing computer extension attribute by name.

Required privileges: extension-attributes:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateComputerGroupByID 

func (c *Client) UpdateComputerGroupByID(ctx context.Context, id string, request *ComputerGroupPost) error

UpdateComputerGroupByID updates an existing computer group by ID.

Required privileges: device-groups:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateComputerGroupByName 

func (c *Client) UpdateComputerGroupByName(ctx context.Context, name string, request *ComputerGroupPost) error

UpdateComputerGroupByName updates an existing computer group by name.

Required privileges: device-groups:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateComputerInventoryCollection 

func (c *Client) UpdateComputerInventoryCollection(ctx context.Context, request *ComputerInventoryCollection) error

UpdateComputerInventoryCollection updates the Jamf Pro computer inventory collection information.

Required privileges: computer-inventory-collection-settings:update.

func (*Client) UpdateDepartmentByID 

func (c *Client) UpdateDepartmentByID(ctx context.Context, id string, request *Department) error

UpdateDepartmentByID updates an existing department by ID.

Required privileges: departments:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateDepartmentByName 

func (c *Client) UpdateDepartmentByName(ctx context.Context, name string, request *Department) error

UpdateDepartmentByName updates an existing department by name.

Required privileges: departments:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateDirectoryBindingByID 

func (c *Client) UpdateDirectoryBindingByID(ctx context.Context, id string, request *DirectoryBinding) error

UpdateDirectoryBindingByID updates an existing directory binding by ID.

Required privileges: directory-bindings:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateDirectoryBindingByName 

func (c *Client) UpdateDirectoryBindingByName(ctx context.Context, name string, request *DirectoryBinding) error

UpdateDirectoryBindingByName updates an existing directory binding by name.

Required privileges: directory-bindings:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateDiskEncryptionConfigurationByID 

func (c *Client) UpdateDiskEncryptionConfigurationByID(ctx context.Context, id string, request *DiskEncryptionConfiguration) error

UpdateDiskEncryptionConfigurationByID updates an existing disk encryption configuration by ID.

Required privileges: disk-encryption-configurations:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateDiskEncryptionConfigurationByName 

func (c *Client) UpdateDiskEncryptionConfigurationByName(ctx context.Context, name string, request *DiskEncryptionConfiguration) error

UpdateDiskEncryptionConfigurationByName updates an existing disk encryption configuration by name.

Required privileges: disk-encryption-configurations:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateDistributionPointByID 

func (c *Client) UpdateDistributionPointByID(ctx context.Context, id string, request *DistributionPointPost) error

UpdateDistributionPointByID updates an existing distribution point by ID.

Required privileges: distribution-points:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateDistributionPointByName 

func (c *Client) UpdateDistributionPointByName(ctx context.Context, name string, request *DistributionPointPost) error

UpdateDistributionPointByName updates an existing distribution point by name.

Required privileges: distribution-points:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateDockItemByID 

func (c *Client) UpdateDockItemByID(ctx context.Context, id string, request *DockItem) error

UpdateDockItemByID updates an existing dock item by ID.

Required privileges: dock-items:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateDockItemByName 

func (c *Client) UpdateDockItemByName(ctx context.Context, name string, request *DockItem) error

UpdateDockItemByName updates an existing dock item by name.

Required privileges: dock-items:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateEbookByID 

func (c *Client) UpdateEbookByID(ctx context.Context, id string, request *EbookPost) error

UpdateEbookByID updates an existing ebook by ID.

Required privileges: ebooks:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateEbookByName 

func (c *Client) UpdateEbookByName(ctx context.Context, name string, request *EbookPost) error

UpdateEbookByName updates an existing ebook by name.

Required privileges: ebooks:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateGSXConnection 

func (c *Client) UpdateGSXConnection(ctx context.Context, request *GsxConnection) error

UpdateGSXConnection updates the Jamf Pro GSX connection information.

Required privileges: gsx-connection:update.

func (*Client) UpdateHealthcareListenerByID 

func (c *Client) UpdateHealthcareListenerByID(ctx context.Context, id string, request *HealthcareListener) error

UpdateHealthcareListenerByID updates an existing healthcare listener by ID.

Required privileges: infrastructure-managers:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateHealthcareListenerRuleByID 

func (c *Client) UpdateHealthcareListenerRuleByID(ctx context.Context, id string, request *HealthcareListenerRule) error

UpdateHealthcareListenerRuleByID updates an existing Healthcare Listener rule by ID.

Required privileges: infrastructure-managers:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateIBeaconByID 

func (c *Client) UpdateIBeaconByID(ctx context.Context, id string, request *Ibeacon) error

UpdateIBeaconByID updates an existing iBeacon region by ID.

Required privileges: ibeacon:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateIBeaconByName 

func (c *Client) UpdateIBeaconByName(ctx context.Context, name string, request *Ibeacon) error

UpdateIBeaconByName updates an existing iBeacon region by name.

Required privileges: ibeacon:update.

Parameters:

  • name: Name to filter by.

func (*Client) UpdateInfrastructureManagerByID 

func (c *Client) UpdateInfrastructureManagerByID(ctx context.Context, id string, request *InfrastructureManager) error

UpdateInfrastructureManagerByID updates an existing infrastructure manager by ID.

Required privileges: infrastructure-managers:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateJsonWebTokenConfigurationByID 

func (c *Client) UpdateJsonWebTokenConfigurationByID(ctx context.Context, id string, request *JsonWebTokenConfiguration) error

UpdateJsonWebTokenConfigurationByID updates an existing JSON Web Token configuration by ID.

Required privileges: json-web-token-configuration:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateLDAPServerByID 

func (c *Client) UpdateLDAPServerByID(ctx context.Context, id string, request *LdapServerPost) error

UpdateLDAPServerByID updates an existing LDAP server by ID.

Required privileges: ldap-servers:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateLDAPServerByName 

func (c *Client) UpdateLDAPServerByName(ctx context.Context, name string, request *LdapServerPost) error

UpdateLDAPServerByName updates an existing LDAP server by name.

Required privileges: ldap-servers:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateLicensedSoftwareByID 

func (c *Client) UpdateLicensedSoftwareByID(ctx context.Context, id string, request *LicensedSoftware) error

UpdateLicensedSoftwareByID updates existing licensed software by ID.

Required privileges: licensed-software:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateLicensedSoftwareByName 

func (c *Client) UpdateLicensedSoftwareByName(ctx context.Context, name string, request *LicensedSoftware) error

UpdateLicensedSoftwareByName updates an existing licensed software by name.

Required privileges: licensed-software:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateMacApplicationByID 

func (c *Client) UpdateMacApplicationByID(ctx context.Context, id string, request *MacApplication) error

UpdateMacApplicationByID updates an existing mac application by ID.

Required privileges: applications:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateMacApplicationByName 

func (c *Client) UpdateMacApplicationByName(ctx context.Context, name string, request *MacApplication) error

UpdateMacApplicationByName updates an existing mac application by name.

Required privileges: applications:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateMobileDeviceApplicationByBundleID 

func (c *Client) UpdateMobileDeviceApplicationByBundleID(ctx context.Context, bundleid string, request *MobileDeviceApplication) error

UpdateMobileDeviceApplicationByBundleID updates an existing mobile device application by bundle ID.

Required privileges: applications:update.

Parameters:

  • bundleid: Bundle ID value to filter by.

func (*Client) UpdateMobileDeviceApplicationByBundleIDVersion 

func (c *Client) UpdateMobileDeviceApplicationByBundleIDVersion(ctx context.Context, bundleid string, version string, request *MobileDeviceApplication) error

UpdateMobileDeviceApplicationByBundleIDVersion updates an existing mobile device application by bundle ID and version.

Required privileges: applications:update.

Parameters:

  • bundleid: Bundle ID value to filter by.
  • version: Version to filter by.

func (*Client) UpdateMobileDeviceApplicationByID 

func (c *Client) UpdateMobileDeviceApplicationByID(ctx context.Context, id string, request *MobileDeviceApplication) error

UpdateMobileDeviceApplicationByID updates an existing mobile device application by ID.

Required privileges: applications:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateMobileDeviceApplicationByName 

func (c *Client) UpdateMobileDeviceApplicationByName(ctx context.Context, name string, request *MobileDeviceApplication) error

UpdateMobileDeviceApplicationByName updates an existing mobile device application by name.

Required privileges: applications:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateMobileDeviceByID 

func (c *Client) UpdateMobileDeviceByID(ctx context.Context, id string, request *MobileDevicePost) error

UpdateMobileDeviceByID updates an existing mobile device by ID.

Required privileges: devices:update, users:update. All of them are required, not alternatives.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateMobileDeviceByMacAddress 

func (c *Client) UpdateMobileDeviceByMacAddress(ctx context.Context, macAddress string, request *MobileDevicePost) error

UpdateMobileDeviceByMacAddress updates an existing mobile device by Mac address.

Required privileges: devices:update, users:update. All of them are required, not alternatives.

Parameters:

  • macAddress: Mac address value to filter by.

func (*Client) UpdateMobileDeviceByName 

func (c *Client) UpdateMobileDeviceByName(ctx context.Context, name string, request *MobileDevicePost) error

UpdateMobileDeviceByName updates an existing mobile device by name.

Required privileges: devices:update, users:update. All of them are required, not alternatives.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateMobileDeviceBySerialNumber 

func (c *Client) UpdateMobileDeviceBySerialNumber(ctx context.Context, serialNumber string, request *MobileDevicePost) error

UpdateMobileDeviceBySerialNumber updates an existing mobile device by serial number.

Required privileges: devices:update, users:update. All of them are required, not alternatives.

Parameters:

  • serialNumber: Serial number value to filter by.

func (*Client) UpdateMobileDeviceByUDID 

func (c *Client) UpdateMobileDeviceByUDID(ctx context.Context, udid string, request *MobileDevicePost) error

UpdateMobileDeviceByUDID updates an existing mobile device by UDID.

Required privileges: devices:update, users:update. All of them are required, not alternatives.

Parameters:

  • udid: UDID value to filter by.

func (*Client) UpdateMobileDeviceConfigurationProfileByID 

func (c *Client) UpdateMobileDeviceConfigurationProfileByID(ctx context.Context, id string, request *MobileDeviceConfigurationProfile) error

UpdateMobileDeviceConfigurationProfileByID updates an existing mobile device configuration profile by ID.

Required privileges: configuration-profiles:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateMobileDeviceConfigurationProfileByName 

func (c *Client) UpdateMobileDeviceConfigurationProfileByName(ctx context.Context, name string, request *MobileDeviceConfigurationProfile) error

UpdateMobileDeviceConfigurationProfileByName updates an existing mobile device configuration profile by name.

Required privileges: configuration-profiles:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateMobileDeviceEnrollmentProfileByID 

func (c *Client) UpdateMobileDeviceEnrollmentProfileByID(ctx context.Context, id string, request *MobileDeviceEnrollmentProfilePost) error

UpdateMobileDeviceEnrollmentProfileByID updates an existing mobile device enrollment profile by ID.

Required privileges: enrollment-profiles:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateMobileDeviceEnrollmentProfileByInvitation 

func (c *Client) UpdateMobileDeviceEnrollmentProfileByInvitation(ctx context.Context, invitation string, request *MobileDeviceEnrollmentProfilePost) error

UpdateMobileDeviceEnrollmentProfileByInvitation updates an existing mobile device enrollment profile by invitation.

Required privileges: enrollment-profiles:update.

Parameters:

  • invitation: Invitation value to filter by.

func (*Client) UpdateMobileDeviceEnrollmentProfileByName 

func (c *Client) UpdateMobileDeviceEnrollmentProfileByName(ctx context.Context, name string, request *MobileDeviceEnrollmentProfilePost) error

UpdateMobileDeviceEnrollmentProfileByName updates an existing mobile device enrollment profile by name.

Required privileges: enrollment-profiles:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateMobileDeviceExtensionAttributeByID 

func (c *Client) UpdateMobileDeviceExtensionAttributeByID(ctx context.Context, id string, request *MobileDeviceExtensionAttribute) error

UpdateMobileDeviceExtensionAttributeByID updates an existing mobile device extension attribute by ID.

Required privileges: extension-attributes:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateMobileDeviceExtensionAttributeByName 

func (c *Client) UpdateMobileDeviceExtensionAttributeByName(ctx context.Context, name string, request *MobileDeviceExtensionAttribute) error

UpdateMobileDeviceExtensionAttributeByName updates an existing mobile device extension attribute by name.

Required privileges: extension-attributes:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateMobileDeviceGroupByID 

func (c *Client) UpdateMobileDeviceGroupByID(ctx context.Context, id string, request *MobileDeviceGroup) error

UpdateMobileDeviceGroupByID updates an existing mobile device group by ID.

Required privileges: device-groups:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateMobileDeviceGroupByName 

func (c *Client) UpdateMobileDeviceGroupByName(ctx context.Context, name string, request *MobileDeviceGroup) error

UpdateMobileDeviceGroupByName updates an existing mobile device group by name.

Required privileges: device-groups:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateMobileDeviceInvitationByInvitation 

func (c *Client) UpdateMobileDeviceInvitationByInvitation(ctx context.Context, invitation string, request *MobileDeviceInvitationPost) (*MobileDeviceInvitation, error)

UpdateMobileDeviceInvitationByInvitation creates a new mobile device invitation by id.

Required privileges: enrollment-invitations:update.

Parameters:

  • invitation: ID value to filter by.

func (*Client) UpdateMobileDeviceProvisioningProfileByID 

func (c *Client) UpdateMobileDeviceProvisioningProfileByID(ctx context.Context, id string, request *MobileDeviceProvisioningProfile) (*MobileDeviceProvisioningProfile, error)

UpdateMobileDeviceProvisioningProfileByID updates an existing mobile device provisioning profiles by id.

Required privileges: provisioning-profiles:update.

Parameters:

  • id: Id value to filter by.

func (*Client) UpdateMobileDeviceProvisioningProfileByName 

func (c *Client) UpdateMobileDeviceProvisioningProfileByName(ctx context.Context, name string, request *MobileDeviceProvisioningProfile) (*MobileDeviceProvisioningProfile, error)

UpdateMobileDeviceProvisioningProfileByName updates an existing mobile device provisioning profiles by name.

Required privileges: provisioning-profiles:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateMobileDeviceProvisioningProfileByUUID 

func (c *Client) UpdateMobileDeviceProvisioningProfileByUUID(ctx context.Context, uuid string, request *MobileDeviceProvisioningProfile) (*MobileDeviceProvisioningProfile, error)

UpdateMobileDeviceProvisioningProfileByUUID updates an existing mobile device provisioning profiles by uuid.

Required privileges: provisioning-profiles:update.

Parameters:

  • uuid: Uuid value to filter by.

func (*Client) UpdateNetworkSegmentByID 

func (c *Client) UpdateNetworkSegmentByID(ctx context.Context, id string, request *NetworkSegmentPost) error

UpdateNetworkSegmentByID updates an existing network segment by ID.

Required privileges: network-segments:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateNetworkSegmentByName 

func (c *Client) UpdateNetworkSegmentByName(ctx context.Context, name string, request *NetworkSegmentPost) error

UpdateNetworkSegmentByName updates an existing network segment by name.

Required privileges: network-segments:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateOSXConfigurationProfileByID 

func (c *Client) UpdateOSXConfigurationProfileByID(ctx context.Context, id string, request *OsXConfigurationProfile) error

UpdateOSXConfigurationProfileByID updates an existing OS X configuration profile by ID.

Required privileges: configuration-profiles:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateOSXConfigurationProfileByName 

func (c *Client) UpdateOSXConfigurationProfileByName(ctx context.Context, name string, request *OsXConfigurationProfile) error

UpdateOSXConfigurationProfileByName updates an existing OS X configuration profile by name.

Required privileges: configuration-profiles:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdatePatchByID deprecated 

func (c *Client) UpdatePatchByID(ctx context.Context, id string, request *SoftwareTitle) error

UpdatePatchByID updates a Patch Software Title by ID (Deprecated - Please transition use to Jamf Pro API endpoint "/v2/patch-software-title-configurations/{id}".).

Deprecated: this endpoint is marked deprecated in the Jamf API spec and may be removed in a future release.

Required privileges: patch-management-software-titles:update.

Parameters:

  • id: ID value to update by.

func (*Client) UpdatePatchExternalSourceByID 

func (c *Client) UpdatePatchExternalSourceByID(ctx context.Context, id string, request *PatchExternalSource) error

UpdatePatchExternalSourceByID updates a patch external source by ID.

Required privileges: patch-external-source:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdatePatchExternalSourceByName 

func (c *Client) UpdatePatchExternalSourceByName(ctx context.Context, name string, request *PatchExternalSource) error

UpdatePatchExternalSourceByName updates a patch external source by name.

Required privileges: patch-external-source:update.

Parameters:

  • name: Name to filter by.

func (*Client) UpdatePatchPolicyByID 

func (c *Client) UpdatePatchPolicyByID(ctx context.Context, id string, request *PatchPolicy) error

UpdatePatchPolicyByID updates an existing patch policy by ID.

Required privileges: patch-policies:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdatePatchSoftwareTitleByID deprecated 

func (c *Client) UpdatePatchSoftwareTitleByID(ctx context.Context, id string, request *PatchSoftwareTitle) error

UpdatePatchSoftwareTitleByID updates a patch software title by ID. (Deprecated) Please transition use to Jamf Pro API endpoint "/v2/patch-software-title-configurations/{id}".

Deprecated: this endpoint is marked deprecated in the Jamf API spec and may be removed in a future release.

Required privileges: patch-management-software-titles:update.

Parameters:

  • id: ID value to update by.

func (*Client) UpdatePolicyByID 

func (c *Client) UpdatePolicyByID(ctx context.Context, id string, request *PolicyPost) error

UpdatePolicyByID updates an existing policy by ID.

Required privileges: policies:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdatePolicyByName 

func (c *Client) UpdatePolicyByName(ctx context.Context, name string, request *PolicyPost) error

UpdatePolicyByName updates an existing policy by name.

Required privileges: policies:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdatePrinterByID 

func (c *Client) UpdatePrinterByID(ctx context.Context, id string, request *Printer) error

UpdatePrinterByID updates an existing printer by ID.

Required privileges: printers:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdatePrinterByName 

func (c *Client) UpdatePrinterByName(ctx context.Context, name string, request *Printer) error

UpdatePrinterByName updates an existing printer by name.

Required privileges: printers:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateRemovableMacAddressByID 

func (c *Client) UpdateRemovableMacAddressByID(ctx context.Context, id string, request *RemovableMacAddress) error

UpdateRemovableMacAddressByID updates an existing removable Mac address by ID.

Required privileges: removable-mac-address:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateRemovableMacAddressByName 

func (c *Client) UpdateRemovableMacAddressByName(ctx context.Context, name string, request *RemovableMacAddress) error

UpdateRemovableMacAddressByName updates an existing removable Mac address by name.

Required privileges: removable-mac-address:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateRestrictedSoftwareByID 

func (c *Client) UpdateRestrictedSoftwareByID(ctx context.Context, id string, request *RestrictedSoftware) error

UpdateRestrictedSoftwareByID updates an existing restricted software by ID.

Required privileges: restricted-software:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateRestrictedSoftwareByName 

func (c *Client) UpdateRestrictedSoftwareByName(ctx context.Context, name string, request *RestrictedSoftware) error

UpdateRestrictedSoftwareByName updates an existing restricted software by name.

Required privileges: restricted-software:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateSMTPServer 

func (c *Client) UpdateSMTPServer(ctx context.Context, request *SmtpServer) error

UpdateSMTPServer updates the Jamf Pro SMTP server information.

Required privileges: smtp-server:update.

func (*Client) UpdateScriptByID 

func (c *Client) UpdateScriptByID(ctx context.Context, id string, request *Script) error

UpdateScriptByID updates an existing script by ID.

Required privileges: scripts:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateScriptByName 

func (c *Client) UpdateScriptByName(ctx context.Context, name string, request *Script) error

UpdateScriptByName updates an existing script by name.

Required privileges: scripts:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateSiteByID 

func (c *Client) UpdateSiteByID(ctx context.Context, id string, request *Site) error

UpdateSiteByID updates an existing site by ID.

Required privileges: sites:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateSiteByName 

func (c *Client) UpdateSiteByName(ctx context.Context, name string, request *Site) error

UpdateSiteByName updates an existing site by name.

Required privileges: sites:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateSoftwareUpdateServerByID 

func (c *Client) UpdateSoftwareUpdateServerByID(ctx context.Context, id string, request *SoftwareUpdateServer) error

UpdateSoftwareUpdateServerByID updates an existing software update server by ID.

Required privileges: software-update-servers:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateSoftwareUpdateServerByName 

func (c *Client) UpdateSoftwareUpdateServerByName(ctx context.Context, name string, request *SoftwareUpdateServer) error

UpdateSoftwareUpdateServerByName updates an existing software update server by name.

Required privileges: software-update-servers:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateUserByID 

func (c *Client) UpdateUserByID(ctx context.Context, id string, request *UserPost) error

UpdateUserByID updates an existing user by ID.

Required privileges: users:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateUserByName 

func (c *Client) UpdateUserByName(ctx context.Context, name string, request *UserPost) error

UpdateUserByName updates an existing user by name.

Required privileges: users:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateUserExtensionAttributeByID 

func (c *Client) UpdateUserExtensionAttributeByID(ctx context.Context, id string, request *UserExtensionAttribute) error

UpdateUserExtensionAttributeByID updates an existing user extension attribute by ID.

Required privileges: user-extension-attributes:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateUserExtensionAttributeByName 

func (c *Client) UpdateUserExtensionAttributeByName(ctx context.Context, name string, request *UserExtensionAttribute) error

UpdateUserExtensionAttributeByName updates an existing user extension attribute by name.

Required privileges: user-extension-attributes:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateUserGroupByID 

func (c *Client) UpdateUserGroupByID(ctx context.Context, id string, request *UserGroup) error

UpdateUserGroupByID updates user groups by ID.

Required privileges: user-groups:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateUserGroupByName 

func (c *Client) UpdateUserGroupByName(ctx context.Context, name string, request *UserGroup) error

UpdateUserGroupByName updates user groups by name.

Required privileges: user-groups:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UpdateVPPAccountByID 

func (c *Client) UpdateVPPAccountByID(ctx context.Context, id string, request *VppAccount) error

UpdateVPPAccountByID updates a VPP account by ID.

Required privileges: volume-purchasing-locations:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateVPPAssignmentByID 

func (c *Client) UpdateVPPAssignmentByID(ctx context.Context, id string, request *VppAssignmentPost) error

UpdateVPPAssignmentByID updates a VPP assignment by ID.

Required privileges: volume-purchasing-locations:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateVPPInvitationByID 

func (c *Client) UpdateVPPInvitationByID(ctx context.Context, id string, request *VppInvitation) error

UpdateVPPInvitationByID updates a VPP invitation by ID.

Required privileges: volume-purchasing-locations:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateWebhookByID 

func (c *Client) UpdateWebhookByID(ctx context.Context, id string, request *Webhook) error

UpdateWebhookByID updates an existing webhook by ID.

Required privileges: webhooks:update.

Parameters:

  • id: ID value to filter by.

func (*Client) UpdateWebhookByName 

func (c *Client) UpdateWebhookByName(ctx context.Context, name string, request *Webhook) error

UpdateWebhookByName updates an existing webhook by name.

Required privileges: webhooks:update.

Parameters:

  • name: Name value to filter by.

func (*Client) UploadFileByResourceIDTypeID 

func (c *Client) UploadFileByResourceIDTypeID(ctx context.Context, resource string, idType string, id string) error

UploadFileByResourceIDTypeID creates file attachments in Jamf Pro.

Required privileges: file-uploads:create.

Parameters:

  • resource: Resource to attach the file to. Allowed values: "computers", "mobiledevices", "enrollmentprofiles", "printers", "peripherals", "policies", "ebooks", "mobiledeviceapplicationsicon", "mobiledeviceapplicationsipa", "diskencryptionconfigurations".
  • idType: Name is supported for all but the peripherals resource. Allowed values: "id", "name".

type Commandflush 

type Commandflush struct {
	XMLName       xml.Name
	ID            *int                       `xml:"id,omitempty"`
	MobileDevices *CommandflushMobileDevices `xml:"mobile_devices,omitempty"`
	// Allowed values: see the CommandflushStatus constants.
	Status *string `xml:"status,omitempty"`
}

Commandflush represents a commandflush.

func (Commandflush) MarshalXML 

func (t Commandflush) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Commandflush root element name to the wire value declared by the spec (<commandflush>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type CommandflushMobileDevices 

type CommandflushMobileDevices struct {
	XMLName      xml.Name
	ID           *int                                   `xml:"id,omitempty"`
	MobileDevice *CommandflushMobileDevicesMobileDevice `xml:"mobile_device,omitempty"`
}

CommandflushMobileDevices represents a commandflush mobile devices.

func (CommandflushMobileDevices) MarshalXML 

func (t CommandflushMobileDevices) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the CommandflushMobileDevices root element name to the wire value declared by the spec (<mobile_devices>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type CommandflushMobileDevicesMobileDevice 

type CommandflushMobileDevicesMobileDevice struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
}

CommandflushMobileDevicesMobileDevice represents a commandflush mobile devices mobile device.

func (CommandflushMobileDevicesMobileDevice) MarshalXML 

func (t CommandflushMobileDevicesMobileDevice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the CommandflushMobileDevicesMobileDevice root element name to the wire value declared by the spec (<mobile_device>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type CommandflushStatus 

type CommandflushStatus = string

CommandflushStatus is the set of values accepted by Commandflush.Status. 

const (
	CommandflushStatusPending       CommandflushStatus = "Pending"
	CommandflushStatusFailed        CommandflushStatus = "Failed"
	CommandflushStatusPendingFailed CommandflushStatus = "Pending+Failed"
)

CommandflushStatus 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 CommandflushStatusValues 

func CommandflushStatusValues() []CommandflushStatus

CommandflushStatusValues returns every value the Jamf API accepts for CommandflushStatus, 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 ComputerApplicationUsage 

type ComputerApplicationUsage struct {
	XMLName xml.Name
	Usages  []ComputerApplicationUsageItemUsage `xml:"usage"`
}

ComputerApplicationUsage wraps a Jamf Classic list response with a flat slice of ComputerApplicationUsageItemUsage.

func (ComputerApplicationUsage) MarshalXML 

func (t ComputerApplicationUsage) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerApplicationUsage root element name to the wire value declared by the spec (<computer_application_usage>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerApplicationUsageApp 

type ComputerApplicationUsageApp struct {
	// Number of minutes application was in the foreground.
	Foreground *int    `xml:"foreground,omitempty"`
	Name       *string `xml:"name,omitempty"`
	// Number of minutes the application was open.
	Open    *int    `xml:"open,omitempty"`
	Version *string `xml:"version,omitempty"`
}

ComputerApplicationUsageApp represents a computer application usage app.

type ComputerApplicationUsageDate 

type ComputerApplicationUsageDate = string

ComputerApplicationUsageDate is an alias for string.

type ComputerApplicationUsageItem 

type ComputerApplicationUsageItem struct {
	XMLName xml.Name
	ID      *int                               `xml:"id,omitempty"`
	Usage   *ComputerApplicationUsageItemUsage `xml:"usage,omitempty"`
}

ComputerApplicationUsageItem represents a computer application usage item.

func (ComputerApplicationUsageItem) MarshalXML 

func (t ComputerApplicationUsageItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerApplicationUsageItem root element name to the wire value declared by the spec (<computer_application_usage>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerApplicationUsageItemUsage 

type ComputerApplicationUsageItemUsage struct {
	XMLName xml.Name
	ID      *int                                   `xml:"id,omitempty"`
	Apps    *ComputerApplicationUsageItemUsageApps `xml:"apps,omitempty"`
	Date    *ComputerApplicationUsageDate          `xml:"date,omitempty"`
}

ComputerApplicationUsageItemUsage represents a computer application usage item usage.

func (ComputerApplicationUsageItemUsage) MarshalXML 

func (t ComputerApplicationUsageItemUsage) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerApplicationUsageItemUsage root element name to the wire value declared by the spec (<usage>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerApplicationUsageItemUsageApps 

type ComputerApplicationUsageItemUsageApps struct {
	XMLName xml.Name
	App     *[]ComputerApplicationUsageApp `xml:"app,omitempty"`
}

ComputerApplicationUsageItemUsageApps represents a computer application usage item usage apps.

func (ComputerApplicationUsageItemUsageApps) MarshalXML 

func (t ComputerApplicationUsageItemUsageApps) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerApplicationUsageItemUsageApps root element name to the wire value declared by the spec (<apps>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerApplications 

type ComputerApplications struct {
	XMLName         xml.Name
	ID              *int                                 `xml:"id,omitempty"`
	UniqueComputers *ComputerApplicationsUniqueComputers `xml:"unique_computers,omitempty"`
	Versions        *ComputerApplicationsVersions        `xml:"versions,omitempty"`
}

ComputerApplications represents a computer applications.

func (ComputerApplications) MarshalXML 

func (t ComputerApplications) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerApplications root element name to the wire value declared by the spec (<computer_applications>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerApplicationsComputer 

type ComputerApplicationsComputer struct {
	ID           *int    `xml:"id,omitempty"`
	MacAddress   *string `xml:"mac_address,omitempty"`
	Name         *string `xml:"name,omitempty"`
	SerialNumber *string `xml:"serial_number,omitempty"`
	UDID         *string `xml:"udid,omitempty"`
}

ComputerApplicationsComputer represents a computer applications computer.

type ComputerApplicationsNumber 

type ComputerApplicationsNumber = string

ComputerApplicationsNumber is an alias for string.

type ComputerApplicationsUniqueComputers 

type ComputerApplicationsUniqueComputers struct {
	XMLName  xml.Name
	Computer *[]ComputerApplicationsComputer `xml:"computer,omitempty"`
}

ComputerApplicationsUniqueComputers represents a computer applications unique computers.

func (ComputerApplicationsUniqueComputers) MarshalXML 

func (t ComputerApplicationsUniqueComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerApplicationsUniqueComputers root element name to the wire value declared by the spec (<unique_computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerApplicationsVersion 

type ComputerApplicationsVersion = []ComputerApplicationsVersionItem

ComputerApplicationsVersion is a list of ComputerApplicationsVersionItem.

type ComputerApplicationsVersionItem 

type ComputerApplicationsVersionItem struct {
	XMLName   xml.Name
	ID        *int                                      `xml:"id,omitempty"`
	Computers *ComputerApplicationsVersionItemComputers `xml:"computers,omitempty"`
	Number    *ComputerApplicationsNumber               `xml:"number,omitempty"`
}

ComputerApplicationsVersionItem represents a computer applications version item.

func (ComputerApplicationsVersionItem) MarshalXML 

func (t ComputerApplicationsVersionItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerApplicationsVersionItem root element name to the wire value declared by the spec (<computer_applications_version>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerApplicationsVersionItemComputers 

type ComputerApplicationsVersionItemComputers struct {
	XMLName  xml.Name
	Computer *[]ComputerApplicationsComputer `xml:"computer,omitempty"`
}

ComputerApplicationsVersionItemComputers represents a computer applications version item computers.

func (ComputerApplicationsVersionItemComputers) MarshalXML 

func (t ComputerApplicationsVersionItemComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerApplicationsVersionItemComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerApplicationsVersions 

type ComputerApplicationsVersions struct {
	XMLName xml.Name
	Version *[]ComputerApplicationsVersion `xml:"version,omitempty"`
}

ComputerApplicationsVersions represents a computer applications versions.

func (ComputerApplicationsVersions) MarshalXML 

func (t ComputerApplicationsVersions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerApplicationsVersions root element name to the wire value declared by the spec (<versions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerCheckIn 

type ComputerCheckIn struct {
	XMLName                       xml.Name
	CheckForPoliciesAtLoginLogout *bool `xml:"check_for_policies_at_login_logout,omitempty"`
	CheckForPoliciesAtStartup     *bool `xml:"check_for_policies_at_startup,omitempty"`
	// Measured in minutes.
	// Allowed values: see the ComputerCheckInCheckInFrequency constants.
	CheckInFrequency       *int  `xml:"check_in_frequency,omitempty"`
	CreateLoginLogoutHooks *bool `xml:"create_login_logout_hooks,omitempty"`
	CreateStartupScript    *bool `xml:"create_startup_script,omitempty"`
	DisplayStatusToUser    *bool `xml:"display_status_to_user,omitempty"`
	EnsureSshIsEnabled     *bool `xml:"ensure_ssh_is_enabled,omitempty"`
	LogStartupEvent        *bool `xml:"log_startup_event,omitempty"`
	LogUsername            *bool `xml:"log_username,omitempty"`
}

ComputerCheckIn represents a computer check in.

func (ComputerCheckIn) MarshalXML 

func (t ComputerCheckIn) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerCheckIn root element name to the wire value declared by the spec (<computer_check_in>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerCheckInCheckInFrequency 

type ComputerCheckInCheckInFrequency = int

ComputerCheckInCheckInFrequency is the set of values accepted by ComputerCheckIn.CheckInFrequency. 

const (
	ComputerCheckInCheckInFrequency60 ComputerCheckInCheckInFrequency = 60
	ComputerCheckInCheckInFrequency30 ComputerCheckInCheckInFrequency = 30
	ComputerCheckInCheckInFrequency15 ComputerCheckInCheckInFrequency = 15
	ComputerCheckInCheckInFrequency5  ComputerCheckInCheckInFrequency = 5
)

ComputerCheckInCheckInFrequency 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 ComputerCheckInCheckInFrequencyValues 

func ComputerCheckInCheckInFrequencyValues() []ComputerCheckInCheckInFrequency

ComputerCheckInCheckInFrequencyValues returns every value the Jamf API accepts for ComputerCheckInCheckInFrequency, 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 ComputerCommand 

type ComputerCommand struct {
	XMLName   xml.Name
	ID        *int                      `xml:"id,omitempty"`
	Computers *ComputerCommandComputers `xml:"computers,omitempty"`
	General   *ComputerCommandGeneral   `xml:"general,omitempty"`
}

ComputerCommand represents a computer command.

func (ComputerCommand) MarshalXML 

func (t ComputerCommand) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerCommand root element name to the wire value declared by the spec (<computer_command>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerCommandComputers 

type ComputerCommandComputers struct {
	XMLName  xml.Name
	ID       *int                              `xml:"id,omitempty"`
	Computer *ComputerCommandComputersComputer `xml:"computer,omitempty"`
	Size     *Size                             `xml:"size,omitempty"`
}

ComputerCommandComputers represents a computer command computers.

func (ComputerCommandComputers) MarshalXML 

func (t ComputerCommandComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerCommandComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerCommandComputersComputer 

type ComputerCommandComputersComputer struct {
	XMLName      xml.Name
	ID           *int    `xml:"id,omitempty"`
	SerialNumber *string `xml:"serial_number,omitempty"`
	UDID         *string `xml:"udid,omitempty"`
}

ComputerCommandComputersComputer represents a computer command computers computer.

func (ComputerCommandComputersComputer) MarshalXML 

func (t ComputerCommandComputersComputer) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerCommandComputersComputer root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerCommandGeneral 

type ComputerCommandGeneral struct {
	XMLName          xml.Name
	ApnsResultStatus *string `xml:"apns_result_status,omitempty"`
	// Command type.
	Command       *string `xml:"command,omitempty"`
	DateSent      *string `xml:"date_sent,omitempty"`
	DateSentEpoch *BigInt `xml:"date_sent_epoch"`
	DateSentUtc   *string `xml:"date_sent_utc,omitempty"`
	ID            *int    `xml:"id,omitempty"`
	ProfileID     *int    `xml:"profile_id,omitempty"`
	ProfileUDID   *string `xml:"profile_udid,omitempty"`
	UDID          *string `xml:"udid,omitempty"`
	UUID          *string `xml:"uuid,omitempty"`
}

ComputerCommandGeneral represents a computer command general.

func (ComputerCommandGeneral) MarshalXML 

func (t ComputerCommandGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerCommandGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerCommandPost 

type ComputerCommandPost struct {
	XMLName   xml.Name
	ID        *int                          `xml:"id,omitempty"`
	Computers *ComputerCommandPostComputers `xml:"computers,omitempty"`
	General   *ComputerCommandPostGeneral   `xml:"general,omitempty"`
}

ComputerCommandPost represents a computer command post.

func (ComputerCommandPost) MarshalXML 

func (t ComputerCommandPost) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerCommandPost root element name to the wire value declared by the spec (<computer_command>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerCommandPostComputers 

type ComputerCommandPostComputers struct {
	XMLName  xml.Name
	ID       *int                              `xml:"id,omitempty"`
	Computer *ComputerCommandComputersComputer `xml:"computer,omitempty"`
	Size     *Size                             `xml:"size,omitempty"`
}

ComputerCommandPostComputers represents a computer command post computers.

func (ComputerCommandPostComputers) MarshalXML 

func (t ComputerCommandPostComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerCommandPostComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerCommandPostGeneral 

type ComputerCommandPostGeneral struct {
	XMLName          xml.Name
	ApnsResultStatus *string `xml:"apns_result_status,omitempty"`
	// Command type.
	Command       *string `xml:"command,omitempty"`
	DateSent      *string `xml:"date_sent,omitempty"`
	DateSentEpoch *BigInt `xml:"date_sent_epoch"`
	DateSentUtc   *string `xml:"date_sent_utc,omitempty"`
	ID            *int    `xml:"id,omitempty"`
	ProfileID     *int    `xml:"profile_id,omitempty"`
	ProfileUDID   *string `xml:"profile_udid,omitempty"`
	UDID          *string `xml:"udid,omitempty"`
	UUID          *string `xml:"uuid,omitempty"`
}

ComputerCommandPostGeneral represents a computer command post general.

func (ComputerCommandPostGeneral) MarshalXML 

func (t ComputerCommandPostGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerCommandPostGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerCommands 

type ComputerCommands struct {
	XMLName          xml.Name
	Size             *Size                                 `xml:"size,omitempty"`
	ComputerCommands []ComputerCommandsItemComputerCommand `xml:"computer_command"`
}

ComputerCommands wraps a Jamf Classic list response with a flat slice of ComputerCommandsItemComputerCommand.

func (ComputerCommands) MarshalXML 

func (t ComputerCommands) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerCommands root element name to the wire value declared by the spec (<computer_commands>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerCommandsItem 

type ComputerCommandsItem struct {
	XMLName         xml.Name
	ID              *int                                 `xml:"id,omitempty"`
	ComputerCommand *ComputerCommandsItemComputerCommand `xml:"computer_command,omitempty"`
	Size            *Size                                `xml:"size,omitempty"`
}

ComputerCommandsItem represents a computer commands item.

func (ComputerCommandsItem) MarshalXML 

func (t ComputerCommandsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerCommandsItem root element name to the wire value declared by the spec (<computer_command>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerCommandsItemComputerCommand 

type ComputerCommandsItemComputerCommand struct {
	XMLName xml.Name
	// Command type.
	Command   *string                                       `xml:"command,omitempty"`
	Computers *ComputerCommandsItemComputerCommandComputers `xml:"computers,omitempty"`
	ID        *int                                          `xml:"id,omitempty"`
	ProfileID *int                                          `xml:"profile_id,omitempty"`
	UDID      *string                                       `xml:"udid,omitempty"`
	UUID      *string                                       `xml:"uuid,omitempty"`
}

ComputerCommandsItemComputerCommand represents a computer commands item computer command.

func (ComputerCommandsItemComputerCommand) MarshalXML 

func (t ComputerCommandsItemComputerCommand) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerCommandsItemComputerCommand root element name to the wire value declared by the spec (<computer_command>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerCommandsItemComputerCommandComputers 

type ComputerCommandsItemComputerCommandComputers struct {
	XMLName  xml.Name
	Computer *[]ComputerCommandsItemComputerCommandComputersComputerItem `xml:"computer,omitempty"`
	Size     *Size                                                       `xml:"size,omitempty"`
}

ComputerCommandsItemComputerCommandComputers represents a computer commands item computer command computers.

func (ComputerCommandsItemComputerCommandComputers) MarshalXML 

func (t ComputerCommandsItemComputerCommandComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerCommandsItemComputerCommandComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerCommandsItemComputerCommandComputersComputerItem 

type ComputerCommandsItemComputerCommandComputersComputerItem struct {
	XMLName   xml.Name
	ID        *int    `xml:"id,omitempty"`
	IPAddress *string `xml:"ip_address,omitempty"`
	UDID      *string `xml:"udid,omitempty"`
	Users     *string `xml:"users,omitempty"`
}

ComputerCommandsItemComputerCommandComputersComputerItem represents a computer commands item computer command computers computer item.

func (ComputerCommandsItemComputerCommandComputersComputerItem) MarshalXML 

func (t ComputerCommandsItemComputerCommandComputersComputerItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerCommandsItemComputerCommandComputersComputerItem root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerExtensionAttribute 

type ComputerExtensionAttribute struct {
	XMLName xml.Name
	// Allowed values: see the ComputerExtensionAttributeDataType constants.
	DataType *string `xml:"data_type,omitempty"`
	// Description of the extension attribute.
	Description *string `xml:"description,omitempty"`
	// Only applicable to script input type.
	Enabled   *bool                                `xml:"enabled,omitempty"`
	ID        *int                                 `xml:"id,omitempty"`
	InputType *ComputerExtensionAttributeInputType `xml:"input_type,omitempty"`
	// Category in which to display the extension attribute in Jamf Pro.
	// Allowed values: see the ComputerExtensionAttributeInventoryDisplay constants.
	InventoryDisplay *string `xml:"inventory_display,omitempty"`
	// Extension attribute name.
	Name *string `xml:"name,omitempty"`
}

ComputerExtensionAttribute represents a computer extension attribute.

func (ComputerExtensionAttribute) MarshalXML 

func (t ComputerExtensionAttribute) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerExtensionAttribute root element name to the wire value declared by the spec (<computer_extension_attribute>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerExtensionAttributeDataType 

type ComputerExtensionAttributeDataType = string

ComputerExtensionAttributeDataType is the set of values accepted by ComputerExtensionAttribute.DataType. 

const (
	ComputerExtensionAttributeDataTypeString  ComputerExtensionAttributeDataType = "String"
	ComputerExtensionAttributeDataTypeInteger ComputerExtensionAttributeDataType = "Integer"
	ComputerExtensionAttributeDataTypeDate    ComputerExtensionAttributeDataType = "Date"
)

ComputerExtensionAttributeDataType 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 ComputerExtensionAttributeDataTypeValues 

func ComputerExtensionAttributeDataTypeValues() []ComputerExtensionAttributeDataType

ComputerExtensionAttributeDataTypeValues returns every value the Jamf API accepts for ComputerExtensionAttributeDataType, 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 ComputerExtensionAttributeInputType 

type ComputerExtensionAttributeInputType struct {
	XMLName      xml.Name
	ID           *int                                             `xml:"id,omitempty"`
	Platform     *string                                          `xml:"platform,omitempty"`
	PopupChoices *ComputerExtensionAttributeInputTypePopupChoices `xml:"popup_choices,omitempty"`
	Script       *string                                          `xml:"script,omitempty"`
	// Allowed values: see the ComputerExtensionAttributeInputTypeType constants.
	Type *string `xml:"type,omitempty"`
}

ComputerExtensionAttributeInputType represents a computer extension attribute input type.

func (ComputerExtensionAttributeInputType) MarshalXML 

func (t ComputerExtensionAttributeInputType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerExtensionAttributeInputType root element name to the wire value declared by the spec (<input_type>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerExtensionAttributeInputTypePopupChoices 

type ComputerExtensionAttributeInputTypePopupChoices struct {
	XMLName xml.Name
	Choice  *[]string `xml:"choice,omitempty"`
}

ComputerExtensionAttributeInputTypePopupChoices represents a computer extension attribute input type popup choices.

func (ComputerExtensionAttributeInputTypePopupChoices) MarshalXML 

func (t ComputerExtensionAttributeInputTypePopupChoices) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerExtensionAttributeInputTypePopupChoices root element name to the wire value declared by the spec (<popup_choices>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerExtensionAttributeInputTypeType 

type ComputerExtensionAttributeInputTypeType = string

ComputerExtensionAttributeInputTypeType is the set of values accepted by ComputerExtensionAttributeInputType.Type. 

const (
	ComputerExtensionAttributeInputTypeTypeScript      ComputerExtensionAttributeInputTypeType = "script"
	ComputerExtensionAttributeInputTypeTypeTextField   ComputerExtensionAttributeInputTypeType = "Text Field"
	ComputerExtensionAttributeInputTypeTypeLdapMapping ComputerExtensionAttributeInputTypeType = "LDAP Mapping"
	ComputerExtensionAttributeInputTypeTypePopUpMenu   ComputerExtensionAttributeInputTypeType = "Pop-up Menu"
)

ComputerExtensionAttributeInputTypeType 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 ComputerExtensionAttributeInputTypeTypeValues 

func ComputerExtensionAttributeInputTypeTypeValues() []ComputerExtensionAttributeInputTypeType

ComputerExtensionAttributeInputTypeTypeValues returns every value the Jamf API accepts for ComputerExtensionAttributeInputTypeType, 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 ComputerExtensionAttributeInventoryDisplay 

type ComputerExtensionAttributeInventoryDisplay = string

ComputerExtensionAttributeInventoryDisplay is the set of values accepted by ComputerExtensionAttribute.InventoryDisplay. 

const (
	ComputerExtensionAttributeInventoryDisplayGeneral             ComputerExtensionAttributeInventoryDisplay = "General"
	ComputerExtensionAttributeInventoryDisplayHardware            ComputerExtensionAttributeInventoryDisplay = "Hardware"
	ComputerExtensionAttributeInventoryDisplayOperatingSystem     ComputerExtensionAttributeInventoryDisplay = "Operating System"
	ComputerExtensionAttributeInventoryDisplayUserAndLocation     ComputerExtensionAttributeInventoryDisplay = "User and Location"
	ComputerExtensionAttributeInventoryDisplayPurchasing          ComputerExtensionAttributeInventoryDisplay = "Purchasing"
	ComputerExtensionAttributeInventoryDisplayExtensionAttributes ComputerExtensionAttributeInventoryDisplay = "Extension Attributes"
)

ComputerExtensionAttributeInventoryDisplay 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 ComputerExtensionAttributeInventoryDisplayValues 

func ComputerExtensionAttributeInventoryDisplayValues() []ComputerExtensionAttributeInventoryDisplay

ComputerExtensionAttributeInventoryDisplayValues returns every value the Jamf API accepts for ComputerExtensionAttributeInventoryDisplay, 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 ComputerExtensionAttributes 

type ComputerExtensionAttributes struct {
	XMLName                     xml.Name
	Size                        *Size                                                       `xml:"size,omitempty"`
	ComputerExtensionAttributes []ComputerExtensionAttributesItemComputerExtensionAttribute `xml:"computer_extension_attribute"`
}

ComputerExtensionAttributes wraps a Jamf Classic list response with a flat slice of ComputerExtensionAttributesItemComputerExtensionAttribute.

func (ComputerExtensionAttributes) MarshalXML 

func (t ComputerExtensionAttributes) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerExtensionAttributes root element name to the wire value declared by the spec (<computer_extension_attributes>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerExtensionAttributesItem 

type ComputerExtensionAttributesItem struct {
	XMLName                    xml.Name
	ID                         *int                                                       `xml:"id,omitempty"`
	ComputerExtensionAttribute *ComputerExtensionAttributesItemComputerExtensionAttribute `xml:"computer_extension_attribute,omitempty"`
	Size                       *Size                                                      `xml:"size,omitempty"`
}

ComputerExtensionAttributesItem represents a computer extension attributes item.

func (ComputerExtensionAttributesItem) MarshalXML 

func (t ComputerExtensionAttributesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerExtensionAttributesItem root element name to the wire value declared by the spec (<computer_extension_attribute>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerExtensionAttributesItemComputerExtensionAttribute 

type ComputerExtensionAttributesItemComputerExtensionAttribute struct {
	XMLName xml.Name
	Enabled *bool   `xml:"enabled,omitempty"`
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
}

ComputerExtensionAttributesItemComputerExtensionAttribute represents a computer extension attributes item computer extension attribute.

func (ComputerExtensionAttributesItemComputerExtensionAttribute) MarshalXML 

func (t ComputerExtensionAttributesItemComputerExtensionAttribute) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerExtensionAttributesItemComputerExtensionAttribute root element name to the wire value declared by the spec (<computer_extension_attribute>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerGroup 

type ComputerGroup struct {
	XMLName   xml.Name
	Computers *ComputerGroupComputers `xml:"computers,omitempty"`
	Criteria  *ComputerGroupCriteria  `xml:"criteria,omitempty"`
	ID        *int                    `xml:"id,omitempty"`
	// Smart or static group.
	IsSmart *bool `xml:"is_smart,omitempty"`
	// Name of the group.
	Name *string     `xml:"name,omitempty"`
	Site *SiteObject `xml:"site,omitempty"`
}

ComputerGroup represents a computer group.

func (ComputerGroup) MarshalXML 

func (t ComputerGroup) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerGroup root element name to the wire value declared by the spec (<computer_group>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerGroupComputers 

type ComputerGroupComputers struct {
	XMLName  xml.Name
	Computer *[]ComputerGroupComputersComputerItem `xml:"computer,omitempty"`
	Size     *Size                                 `xml:"size,omitempty"`
}

ComputerGroupComputers represents a computer group computers.

func (ComputerGroupComputers) MarshalXML 

func (t ComputerGroupComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerGroupComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerGroupComputersComputerItem 

type ComputerGroupComputersComputerItem struct {
	XMLName       xml.Name
	AltMacAddress *string `xml:"alt_mac_address,omitempty"`
	ID            *int    `xml:"id,omitempty"`
	MacAddress    *string `xml:"mac_address,omitempty"`
	// Name of the computer.
	Name         *string `xml:"name,omitempty"`
	SerialNumber *string `xml:"serial_number,omitempty"`
}

ComputerGroupComputersComputerItem represents a computer group computers computer item.

func (ComputerGroupComputersComputerItem) MarshalXML 

func (t ComputerGroupComputersComputerItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerGroupComputersComputerItem root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerGroupCriteria 

type ComputerGroupCriteria struct {
	XMLName   xml.Name
	Criterion *[]Criterion `xml:"criterion,omitempty"`
	Size      *Size        `xml:"size,omitempty"`
}

ComputerGroupCriteria represents a computer group criteria.

func (ComputerGroupCriteria) MarshalXML 

func (t ComputerGroupCriteria) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerGroupCriteria root element name to the wire value declared by the spec (<criteria>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerGroupPost 

type ComputerGroupPost struct {
	XMLName   xml.Name
	Computers *ComputerGroupPostComputers `xml:"computers,omitempty"`
	Criteria  *ComputerGroupPostCriteria  `xml:"criteria,omitempty"`
	ID        *int                        `xml:"id,omitempty"`
	// Smart or static group.
	IsSmart *bool `xml:"is_smart,omitempty"`
	// Name of the group.
	Name *string     `xml:"name,omitempty"`
	Site *SiteObject `xml:"site,omitempty"`
}

ComputerGroupPost represents a computer group post.

func (ComputerGroupPost) MarshalXML 

func (t ComputerGroupPost) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerGroupPost root element name to the wire value declared by the spec (<computer_group>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerGroupPostComputers 

type ComputerGroupPostComputers struct {
	XMLName  xml.Name
	Computer *[]ComputerGroupPostComputersComputerItem `xml:"computer,omitempty"`
	Size     *Size                                     `xml:"size,omitempty"`
}

ComputerGroupPostComputers represents a computer group post computers.

func (ComputerGroupPostComputers) MarshalXML 

func (t ComputerGroupPostComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerGroupPostComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerGroupPostComputersComputerItem 

type ComputerGroupPostComputersComputerItem struct {
	XMLName       xml.Name
	AltMacAddress *string `xml:"alt_mac_address,omitempty"`
	ID            *int    `xml:"id,omitempty"`
	MacAddress    *string `xml:"mac_address,omitempty"`
	// Name of the computer.
	Name         *string `xml:"name,omitempty"`
	SerialNumber *string `xml:"serial_number,omitempty"`
}

ComputerGroupPostComputersComputerItem represents a computer group post computers computer item.

func (ComputerGroupPostComputersComputerItem) MarshalXML 

func (t ComputerGroupPostComputersComputerItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerGroupPostComputersComputerItem root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerGroupPostCriteria 

type ComputerGroupPostCriteria struct {
	XMLName   xml.Name
	Criterion *[]Criterion `xml:"criterion,omitempty"`
	Size      *Size        `xml:"size,omitempty"`
}

ComputerGroupPostCriteria represents a computer group post criteria.

func (ComputerGroupPostCriteria) MarshalXML 

func (t ComputerGroupPostCriteria) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerGroupPostCriteria root element name to the wire value declared by the spec (<criteria>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerGroups 

type ComputerGroups struct {
	XMLName        xml.Name
	Size           *Size                                 `xml:"size,omitempty"`
	ComputerGroups []ComputerGroupsItemComputerGroupItem `xml:"computer_group"`
}

ComputerGroups wraps a Jamf Classic list response with a flat slice of ComputerGroupsItemComputerGroupItem.

func (ComputerGroups) MarshalXML 

func (t ComputerGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerGroups root element name to the wire value declared by the spec (<computer_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerGroupsItem 

type ComputerGroupsItem struct {
	XMLName       xml.Name
	ComputerGroup *[]ComputerGroupsItemComputerGroupItem `xml:"computer_group,omitempty"`
	Size          *Size                                  `xml:"size,omitempty"`
}

ComputerGroupsItem represents a computer groups item.

func (ComputerGroupsItem) MarshalXML 

func (t ComputerGroupsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerGroupsItem root element name to the wire value declared by the spec (<computer_group>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerGroupsItemComputerGroupItem 

type ComputerGroupsItemComputerGroupItem struct {
	XMLName xml.Name
	ID      *int  `xml:"id,omitempty"`
	IsSmart *bool `xml:"is_smart,omitempty"`
	// Name of the group.
	Name *string `xml:"name,omitempty"`
}

ComputerGroupsItemComputerGroupItem represents a computer groups item computer group item.

func (ComputerGroupsItemComputerGroupItem) MarshalXML 

func (t ComputerGroupsItemComputerGroupItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerGroupsItemComputerGroupItem root element name to the wire value declared by the spec (<computer_group>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHardwareSoftwareReports 

type ComputerHardwareSoftwareReports struct {
	XMLName        xml.Name
	ID             *int                                           `xml:"id,omitempty"`
	FontReport     *ComputerHardwareSoftwareReportsFontReport     `xml:"font_report,omitempty"`
	HardwareReport *ComputerHardwareSoftwareReportsHardwareReport `xml:"hardware_report,omitempty"`
	PluginReport   *ComputerHardwareSoftwareReportsPluginReport   `xml:"plugin_report,omitempty"`
	SoftwareReport *ComputerHardwareSoftwareReportsSoftwareReport `xml:"software_report,omitempty"`
}

ComputerHardwareSoftwareReports represents a computer hardware software reports.

func (ComputerHardwareSoftwareReports) MarshalXML 

func (t ComputerHardwareSoftwareReports) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHardwareSoftwareReports root element name to the wire value declared by the spec (<computer_hardware_software_reports>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHardwareSoftwareReportsFontReport 

type ComputerHardwareSoftwareReportsFontReport struct {
	XMLName       xml.Name
	DateTime      *string `xml:"date_time,omitempty"`
	DateTimeEpoch *string `xml:"date_time_epoch,omitempty"`
	DateTimeUtc   *string `xml:"date_time_utc,omitempty"`
	Name          *string `xml:"name,omitempty"`
	Path          *string `xml:"path,omitempty"`
	// Allowed values: see the ComputerHardwareSoftwareReportsFontReportType constants.
	Type    *string `xml:"type,omitempty"`
	Version *string `xml:"version,omitempty"`
}

ComputerHardwareSoftwareReportsFontReport represents a computer hardware software reports font report.

func (ComputerHardwareSoftwareReportsFontReport) MarshalXML 

func (t ComputerHardwareSoftwareReportsFontReport) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHardwareSoftwareReportsFontReport root element name to the wire value declared by the spec (<font_report>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHardwareSoftwareReportsFontReportType 

type ComputerHardwareSoftwareReportsFontReportType = string

ComputerHardwareSoftwareReportsFontReportType is the set of values accepted by ComputerHardwareSoftwareReportsFontReport.Type. 

const (
	ComputerHardwareSoftwareReportsFontReportTypeAdded   ComputerHardwareSoftwareReportsFontReportType = "Added"
	ComputerHardwareSoftwareReportsFontReportTypeDeleted ComputerHardwareSoftwareReportsFontReportType = "Deleted"
)

ComputerHardwareSoftwareReportsFontReportType 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 ComputerHardwareSoftwareReportsFontReportTypeValues 

func ComputerHardwareSoftwareReportsFontReportTypeValues() []ComputerHardwareSoftwareReportsFontReportType

ComputerHardwareSoftwareReportsFontReportTypeValues returns every value the Jamf API accepts for ComputerHardwareSoftwareReportsFontReportType, 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 ComputerHardwareSoftwareReportsHardwareReport 

type ComputerHardwareSoftwareReportsHardwareReport struct {
	XMLName                  xml.Name
	NICSpeed                 *string `xml:"NIC_speed,omitempty"`
	BootPartitionUsedPercent *int    `xml:"boot_partition_used_percent,omitempty"`
	CoreCount                *int    `xml:"core_count,omitempty"`
	DateTime                 *string `xml:"date_time,omitempty"`
	DateTimeEpoch            *string `xml:"date_time_epoch,omitempty"`
	DateTimeUtc              *string `xml:"date_time_utc,omitempty"`
	Make                     *string `xml:"make,omitempty"`
	ModelIdentifier          *string `xml:"model_identifier,omitempty"`
	OpenRamSlots             *int    `xml:"open_ram_slots,omitempty"`
	OperatingSystem          *string `xml:"operating_system,omitempty"`
	OpticalDrive             *string `xml:"optical_drive,omitempty"`
	ProcessorCount           *int    `xml:"processor_count,omitempty"`
	ProcessorSpeedMhz        *int    `xml:"processor_speed_mhz,omitempty"`
	SerialNumber             *string `xml:"serial_number,omitempty"`
	ServicePack              *string `xml:"service_pack,omitempty"`
	TotalHarddriveSize       *string `xml:"total_harddrive_size,omitempty"`
	TotalRamMb               *int    `xml:"total_ram_mb,omitempty"`
}

ComputerHardwareSoftwareReportsHardwareReport represents a computer hardware software reports hardware report.

func (ComputerHardwareSoftwareReportsHardwareReport) MarshalXML 

func (t ComputerHardwareSoftwareReportsHardwareReport) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHardwareSoftwareReportsHardwareReport root element name to the wire value declared by the spec (<hardware_report>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHardwareSoftwareReportsPluginReport 

type ComputerHardwareSoftwareReportsPluginReport struct {
	XMLName       xml.Name
	DateTime      *string `xml:"date_time,omitempty"`
	DateTimeEpoch *string `xml:"date_time_epoch,omitempty"`
	DateTimeUtc   *string `xml:"date_time_utc,omitempty"`
	Name          *string `xml:"name,omitempty"`
	Path          *string `xml:"path,omitempty"`
	// Allowed values: see the ComputerHardwareSoftwareReportsPluginReportType constants.
	Type    *string `xml:"type,omitempty"`
	Version *string `xml:"version,omitempty"`
}

ComputerHardwareSoftwareReportsPluginReport represents a computer hardware software reports plugin report.

func (ComputerHardwareSoftwareReportsPluginReport) MarshalXML 

func (t ComputerHardwareSoftwareReportsPluginReport) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHardwareSoftwareReportsPluginReport root element name to the wire value declared by the spec (<plugin_report>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHardwareSoftwareReportsPluginReportType 

type ComputerHardwareSoftwareReportsPluginReportType = string

ComputerHardwareSoftwareReportsPluginReportType is the set of values accepted by ComputerHardwareSoftwareReportsPluginReport.Type. 

const (
	ComputerHardwareSoftwareReportsPluginReportTypeAdded   ComputerHardwareSoftwareReportsPluginReportType = "Added"
	ComputerHardwareSoftwareReportsPluginReportTypeRemoved ComputerHardwareSoftwareReportsPluginReportType = "Removed"
)

ComputerHardwareSoftwareReportsPluginReportType 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 ComputerHardwareSoftwareReportsPluginReportTypeValues 

func ComputerHardwareSoftwareReportsPluginReportTypeValues() []ComputerHardwareSoftwareReportsPluginReportType

ComputerHardwareSoftwareReportsPluginReportTypeValues returns every value the Jamf API accepts for ComputerHardwareSoftwareReportsPluginReportType, 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 ComputerHardwareSoftwareReportsSoftwareReport 

type ComputerHardwareSoftwareReportsSoftwareReport struct {
	XMLName       xml.Name
	DateTime      *string `xml:"date_time,omitempty"`
	DateTimeEpoch *string `xml:"date_time_epoch,omitempty"`
	DateTimeUtc   *string `xml:"date_time_utc,omitempty"`
	Name          *string `xml:"name,omitempty"`
	Path          *string `xml:"path,omitempty"`
	// Allowed values: see the ComputerHardwareSoftwareReportsSoftwareReportType constants.
	Type    *string `xml:"type,omitempty"`
	Version *string `xml:"version,omitempty"`
}

ComputerHardwareSoftwareReportsSoftwareReport represents a computer hardware software reports software report.

func (ComputerHardwareSoftwareReportsSoftwareReport) MarshalXML 

func (t ComputerHardwareSoftwareReportsSoftwareReport) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHardwareSoftwareReportsSoftwareReport root element name to the wire value declared by the spec (<software_report>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHardwareSoftwareReportsSoftwareReportType 

type ComputerHardwareSoftwareReportsSoftwareReportType = string

ComputerHardwareSoftwareReportsSoftwareReportType is the set of values accepted by ComputerHardwareSoftwareReportsSoftwareReport.Type. 

const (
	ComputerHardwareSoftwareReportsSoftwareReportTypeAdded   ComputerHardwareSoftwareReportsSoftwareReportType = "Added"
	ComputerHardwareSoftwareReportsSoftwareReportTypeDeleted ComputerHardwareSoftwareReportsSoftwareReportType = "Deleted"
)

ComputerHardwareSoftwareReportsSoftwareReportType 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 ComputerHardwareSoftwareReportsSoftwareReportTypeValues 

func ComputerHardwareSoftwareReportsSoftwareReportTypeValues() []ComputerHardwareSoftwareReportsSoftwareReportType

ComputerHardwareSoftwareReportsSoftwareReportTypeValues returns every value the Jamf API accepts for ComputerHardwareSoftwareReportsSoftwareReportType, 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 ComputerHistory 

type ComputerHistory struct {
	XMLName                 xml.Name
	ID                      *int                                    `xml:"id,omitempty"`
	Audits                  *ComputerHistoryAudits                  `xml:"audits,omitempty"`
	CasperImagingLogs       *ComputerHistoryCasperImagingLogs       `xml:"casper_imaging_logs,omitempty"`
	CasperRemoteLogs        *ComputerHistoryCasperRemoteLogs        `xml:"casper_remote_logs,omitempty"`
	Commands                *ComputerHistoryCommands                `xml:"commands,omitempty"`
	ComputerUsageLogs       *ComputerHistoryComputerUsageLogs       `xml:"computer_usage_logs,omitempty"`
	General                 *ComputerHistoryGeneral                 `xml:"general,omitempty"`
	MacAppStoreApplications *ComputerHistoryMacAppStoreApplications `xml:"mac_app_store_applications,omitempty"`
	PolicyLogs              *ComputerHistoryPolicyLogs              `xml:"policy_logs,omitempty"`
	ScreenSharingLogs       *ComputerHistoryScreenSharingLogs       `xml:"screen_sharing_logs,omitempty"`
	UserLocation            *ComputerHistoryUserLocation            `xml:"user_location,omitempty"`
}

ComputerHistory represents a computer history.

func (ComputerHistory) MarshalXML 

func (t ComputerHistory) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistory root element name to the wire value declared by the spec (<computer_history>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryAudits 

type ComputerHistoryAudits struct {
	XMLName xml.Name
	Audit   *[]ComputerHistoryAuditsAuditItem `xml:"audit,omitempty"`
}

ComputerHistoryAudits represents a computer history audits.

func (ComputerHistoryAudits) MarshalXML 

func (t ComputerHistoryAudits) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryAudits root element name to the wire value declared by the spec (<audits>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryAuditsAuditItem 

type ComputerHistoryAuditsAuditItem struct {
	XMLName       xml.Name
	DateTime      *string `xml:"date_time,omitempty"`
	DateTimeEpoch *string `xml:"date_time_epoch,omitempty"`
	DateTimeUtc   *string `xml:"date_time_utc,omitempty"`
	Event         *string `xml:"event,omitempty"`
	Username      *string `xml:"username,omitempty"`
}

ComputerHistoryAuditsAuditItem represents a computer history audits audit item.

func (ComputerHistoryAuditsAuditItem) MarshalXML 

func (t ComputerHistoryAuditsAuditItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryAuditsAuditItem root element name to the wire value declared by the spec (<audit>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryCasperImagingLogs 

type ComputerHistoryCasperImagingLogs struct {
	XMLName          xml.Name
	CasperImagingLog *[]ComputerHistoryCasperImagingLogsCasperImagingLogItem `xml:"casper_imaging_log,omitempty"`
}

ComputerHistoryCasperImagingLogs represents a computer history casper imaging logs.

func (ComputerHistoryCasperImagingLogs) MarshalXML 

func (t ComputerHistoryCasperImagingLogs) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryCasperImagingLogs root element name to the wire value declared by the spec (<casper_imaging_logs>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryCasperImagingLogsCasperImagingLogItem 

type ComputerHistoryCasperImagingLogsCasperImagingLogItem struct {
	XMLName       xml.Name
	DateTime      *string `xml:"date_time,omitempty"`
	DateTimeEpoch *string `xml:"date_time_epoch,omitempty"`
	DateTimeUtc   *string `xml:"date_time_utc,omitempty"`
	Status        *string `xml:"status,omitempty"`
}

ComputerHistoryCasperImagingLogsCasperImagingLogItem represents a computer history casper imaging logs casper imaging log item.

func (ComputerHistoryCasperImagingLogsCasperImagingLogItem) MarshalXML 

func (t ComputerHistoryCasperImagingLogsCasperImagingLogItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryCasperImagingLogsCasperImagingLogItem root element name to the wire value declared by the spec (<casper_imaging_log>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryCasperRemoteLogs 

type ComputerHistoryCasperRemoteLogs struct {
	XMLName         xml.Name
	CasperRemoteLog *[]ComputerHistoryCasperRemoteLogsCasperRemoteLogItem `xml:"casper_remote_log,omitempty"`
}

ComputerHistoryCasperRemoteLogs represents a computer history casper remote logs.

func (ComputerHistoryCasperRemoteLogs) MarshalXML 

func (t ComputerHistoryCasperRemoteLogs) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryCasperRemoteLogs root element name to the wire value declared by the spec (<casper_remote_logs>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryCasperRemoteLogsCasperRemoteLogItem 

type ComputerHistoryCasperRemoteLogsCasperRemoteLogItem struct {
	XMLName       xml.Name
	DateTime      *string `xml:"date_time,omitempty"`
	DateTimeEpoch *string `xml:"date_time_epoch,omitempty"`
	DateTimeUtc   *string `xml:"date_time_utc,omitempty"`
	Status        *string `xml:"status,omitempty"`
}

ComputerHistoryCasperRemoteLogsCasperRemoteLogItem represents a computer history casper remote logs casper remote log item.

func (ComputerHistoryCasperRemoteLogsCasperRemoteLogItem) MarshalXML 

func (t ComputerHistoryCasperRemoteLogsCasperRemoteLogItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryCasperRemoteLogsCasperRemoteLogItem root element name to the wire value declared by the spec (<casper_remote_log>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryCommands 

type ComputerHistoryCommands struct {
	XMLName   xml.Name
	ID        *int                              `xml:"id,omitempty"`
	Completed *ComputerHistoryCommandsCompleted `xml:"completed,omitempty"`
	Failed    *ComputerHistoryCommandsFailed    `xml:"failed,omitempty"`
	Pending   *ComputerHistoryCommandsPending   `xml:"pending,omitempty"`
}

ComputerHistoryCommands represents a computer history commands.

func (ComputerHistoryCommands) MarshalXML 

func (t ComputerHistoryCommands) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryCommands root element name to the wire value declared by the spec (<commands>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryCommandsCompleted 

type ComputerHistoryCommandsCompleted struct {
	XMLName xml.Name
	Command *[]ComputerHistoryCommandsCompletedCommandItem `xml:"command,omitempty"`
}

ComputerHistoryCommandsCompleted represents a computer history commands completed.

func (ComputerHistoryCommandsCompleted) MarshalXML 

func (t ComputerHistoryCommandsCompleted) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryCommandsCompleted root element name to the wire value declared by the spec (<completed>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryCommandsCompletedCommandItem 

type ComputerHistoryCommandsCompletedCommandItem struct {
	XMLName        xml.Name
	Completed      *string `xml:"completed,omitempty"`
	CompletedEpoch *string `xml:"completed_epoch,omitempty"`
	CompletedUtc   *string `xml:"completed_utc,omitempty"`
	Name           *string `xml:"name,omitempty"`
	Username       *string `xml:"username,omitempty"`
}

ComputerHistoryCommandsCompletedCommandItem represents a computer history commands completed command item.

func (ComputerHistoryCommandsCompletedCommandItem) MarshalXML 

func (t ComputerHistoryCommandsCompletedCommandItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryCommandsCompletedCommandItem root element name to the wire value declared by the spec (<command>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryCommandsFailed 

type ComputerHistoryCommandsFailed struct {
	XMLName xml.Name
	Command *[]ComputerHistoryCommandsFailedCommandItem `xml:"command,omitempty"`
}

ComputerHistoryCommandsFailed represents a computer history commands failed.

func (ComputerHistoryCommandsFailed) MarshalXML 

func (t ComputerHistoryCommandsFailed) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryCommandsFailed root element name to the wire value declared by the spec (<failed>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryCommandsFailedCommandItem 

type ComputerHistoryCommandsFailedCommandItem struct {
	XMLName     xml.Name
	Failed      *string `xml:"failed,omitempty"`
	FailedEpoch *string `xml:"failed_epoch,omitempty"`
	FailedUtc   *string `xml:"failed_utc,omitempty"`
	Issued      *string `xml:"issued,omitempty"`
	IssuedEpoch *string `xml:"issued_epoch,omitempty"`
	IssuedUtc   *string `xml:"issued_utc,omitempty"`
	Name        *string `xml:"name,omitempty"`
	Status      *string `xml:"status,omitempty"`
}

ComputerHistoryCommandsFailedCommandItem represents a computer history commands failed command item.

func (ComputerHistoryCommandsFailedCommandItem) MarshalXML 

func (t ComputerHistoryCommandsFailedCommandItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryCommandsFailedCommandItem root element name to the wire value declared by the spec (<command>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryCommandsPending 

type ComputerHistoryCommandsPending struct {
	XMLName xml.Name
	Command *[]ComputerHistoryCommandsPendingCommandItem `xml:"command,omitempty"`
}

ComputerHistoryCommandsPending represents a computer history commands pending.

func (ComputerHistoryCommandsPending) MarshalXML 

func (t ComputerHistoryCommandsPending) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryCommandsPending root element name to the wire value declared by the spec (<pending>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryCommandsPendingCommandItem 

type ComputerHistoryCommandsPendingCommandItem struct {
	XMLName       xml.Name
	Issued        *string `xml:"issued,omitempty"`
	IssuedEpoch   *string `xml:"issued_epoch,omitempty"`
	IssuedUtc     *string `xml:"issued_utc,omitempty"`
	LastPush      *string `xml:"last_push,omitempty"`
	LastPushEpoch *string `xml:"last_push_epoch,omitempty"`
	LastPushUtc   *string `xml:"last_push_utc,omitempty"`
	Name          *string `xml:"name,omitempty"`
	Status        *string `xml:"status,omitempty"`
	Username      *string `xml:"username,omitempty"`
}

ComputerHistoryCommandsPendingCommandItem represents a computer history commands pending command item.

func (ComputerHistoryCommandsPendingCommandItem) MarshalXML 

func (t ComputerHistoryCommandsPendingCommandItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryCommandsPendingCommandItem root element name to the wire value declared by the spec (<command>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryComputerUsageLogs 

type ComputerHistoryComputerUsageLogs struct {
	XMLName  xml.Name
	UsageLog *[]ComputerHistoryComputerUsageLogsUsageLogItem `xml:"usage_log,omitempty"`
}

ComputerHistoryComputerUsageLogs represents a computer history computer usage logs.

func (ComputerHistoryComputerUsageLogs) MarshalXML 

func (t ComputerHistoryComputerUsageLogs) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryComputerUsageLogs root element name to the wire value declared by the spec (<computer_usage_logs>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryComputerUsageLogsUsageLogItem 

type ComputerHistoryComputerUsageLogsUsageLogItem struct {
	XMLName       xml.Name
	DateTime      *string `xml:"date_time,omitempty"`
	DateTimeEpoch *string `xml:"date_time_epoch,omitempty"`
	DateTimeUtc   *string `xml:"date_time_utc,omitempty"`
	Event         *string `xml:"event,omitempty"`
	Username      *string `xml:"username,omitempty"`
}

ComputerHistoryComputerUsageLogsUsageLogItem represents a computer history computer usage logs usage log item.

func (ComputerHistoryComputerUsageLogsUsageLogItem) MarshalXML 

func (t ComputerHistoryComputerUsageLogsUsageLogItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryComputerUsageLogsUsageLogItem root element name to the wire value declared by the spec (<usage_log>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryGeneral 

type ComputerHistoryGeneral struct {
	XMLName    xml.Name
	ID         *int    `xml:"id,omitempty"`
	MacAddress *string `xml:"mac_address,omitempty"`
	// Name of the computer.
	Name         *string `xml:"name,omitempty"`
	SerialNumber *string `xml:"serial_number,omitempty"`
	UDID         *string `xml:"udid,omitempty"`
}

ComputerHistoryGeneral represents a computer history general.

func (ComputerHistoryGeneral) MarshalXML 

func (t ComputerHistoryGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryMacAppStoreApplications 

type ComputerHistoryMacAppStoreApplications struct {
	XMLName   xml.Name
	ID        *int                                             `xml:"id,omitempty"`
	Failed    *ComputerHistoryMacAppStoreApplicationsFailed    `xml:"failed,omitempty"`
	Installed *ComputerHistoryMacAppStoreApplicationsInstalled `xml:"installed,omitempty"`
	Pending   *ComputerHistoryMacAppStoreApplicationsPending   `xml:"pending,omitempty"`
}

ComputerHistoryMacAppStoreApplications represents a computer history mac app store applications.

func (ComputerHistoryMacAppStoreApplications) MarshalXML 

func (t ComputerHistoryMacAppStoreApplications) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryMacAppStoreApplications root element name to the wire value declared by the spec (<mac_app_store_applications>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryMacAppStoreApplicationsFailed 

type ComputerHistoryMacAppStoreApplicationsFailed struct {
	XMLName xml.Name
	App     *[]ComputerHistoryMacAppStoreApplicationsFailedAppItem `xml:"app,omitempty"`
}

ComputerHistoryMacAppStoreApplicationsFailed represents a computer history mac app store applications failed.

func (ComputerHistoryMacAppStoreApplicationsFailed) MarshalXML 

func (t ComputerHistoryMacAppStoreApplicationsFailed) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryMacAppStoreApplicationsFailed root element name to the wire value declared by the spec (<failed>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryMacAppStoreApplicationsFailedAppItem 

type ComputerHistoryMacAppStoreApplicationsFailedAppItem struct {
	XMLName         xml.Name
	Deployed        *string `xml:"deployed,omitempty"`
	DeployedEpoch   *int    `xml:"deployed_epoch,omitempty"`
	DeployedUtc     *string `xml:"deployed_utc,omitempty"`
	LastUpdate      *string `xml:"last_update,omitempty"`
	LastUpdateEpoch *int    `xml:"last_update_epoch,omitempty"`
	LastUpdateUtc   *string `xml:"last_update_utc,omitempty"`
	Name            *string `xml:"name,omitempty"`
	Status          *string `xml:"status,omitempty"`
	Version         *string `xml:"version,omitempty"`
}

ComputerHistoryMacAppStoreApplicationsFailedAppItem represents a computer history mac app store applications failed app item.

func (ComputerHistoryMacAppStoreApplicationsFailedAppItem) MarshalXML 

func (t ComputerHistoryMacAppStoreApplicationsFailedAppItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryMacAppStoreApplicationsFailedAppItem root element name to the wire value declared by the spec (<app>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryMacAppStoreApplicationsInstalled 

type ComputerHistoryMacAppStoreApplicationsInstalled struct {
	XMLName xml.Name
	App     *[]ComputerHistoryMacAppStoreApplicationsInstalledAppItem `xml:"app,omitempty"`
}

ComputerHistoryMacAppStoreApplicationsInstalled represents a computer history mac app store applications installed.

func (ComputerHistoryMacAppStoreApplicationsInstalled) MarshalXML 

func (t ComputerHistoryMacAppStoreApplicationsInstalled) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryMacAppStoreApplicationsInstalled root element name to the wire value declared by the spec (<installed>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryMacAppStoreApplicationsInstalledAppItem 

type ComputerHistoryMacAppStoreApplicationsInstalledAppItem struct {
	XMLName xml.Name
	Name    *string `xml:"name,omitempty"`
	SizeMb  *string `xml:"size_mb,omitempty"`
	Version *string `xml:"version,omitempty"`
}

ComputerHistoryMacAppStoreApplicationsInstalledAppItem represents a computer history mac app store applications installed app item.

func (ComputerHistoryMacAppStoreApplicationsInstalledAppItem) MarshalXML 

func (t ComputerHistoryMacAppStoreApplicationsInstalledAppItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryMacAppStoreApplicationsInstalledAppItem root element name to the wire value declared by the spec (<app>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryMacAppStoreApplicationsPending 

type ComputerHistoryMacAppStoreApplicationsPending struct {
	XMLName xml.Name
	App     *[]ComputerHistoryMacAppStoreApplicationsPendingAppItem `xml:"app,omitempty"`
}

ComputerHistoryMacAppStoreApplicationsPending represents a computer history mac app store applications pending.

func (ComputerHistoryMacAppStoreApplicationsPending) MarshalXML 

func (t ComputerHistoryMacAppStoreApplicationsPending) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryMacAppStoreApplicationsPending root element name to the wire value declared by the spec (<pending>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryMacAppStoreApplicationsPendingAppItem 

type ComputerHistoryMacAppStoreApplicationsPendingAppItem struct {
	XMLName         xml.Name
	Deployed        *string `xml:"deployed,omitempty"`
	DeployedEpoch   *int    `xml:"deployed_epoch,omitempty"`
	DeployedUtc     *string `xml:"deployed_utc,omitempty"`
	LastUpdate      *string `xml:"last_update,omitempty"`
	LastUpdateEpoch *int    `xml:"last_update_epoch,omitempty"`
	LastUpdateUtc   *string `xml:"last_update_utc,omitempty"`
	Name            *string `xml:"name,omitempty"`
	Version         *string `xml:"version,omitempty"`
}

ComputerHistoryMacAppStoreApplicationsPendingAppItem represents a computer history mac app store applications pending app item.

func (ComputerHistoryMacAppStoreApplicationsPendingAppItem) MarshalXML 

func (t ComputerHistoryMacAppStoreApplicationsPendingAppItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryMacAppStoreApplicationsPendingAppItem root element name to the wire value declared by the spec (<app>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryPolicyLogs 

type ComputerHistoryPolicyLogs struct {
	XMLName   xml.Name
	PolicyLog *[]ComputerHistoryPolicyLogsPolicyLogItem `xml:"policy_log,omitempty"`
}

ComputerHistoryPolicyLogs represents a computer history policy logs.

func (ComputerHistoryPolicyLogs) MarshalXML 

func (t ComputerHistoryPolicyLogs) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryPolicyLogs root element name to the wire value declared by the spec (<policy_logs>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryPolicyLogsPolicyLogItem 

type ComputerHistoryPolicyLogsPolicyLogItem struct {
	XMLName       xml.Name
	DateTime      *string `xml:"date_time,omitempty"`
	DateTimeEpoch *string `xml:"date_time_epoch,omitempty"`
	DateTimeUtc   *string `xml:"date_time_utc,omitempty"`
	PolicyID      *int    `xml:"policy_id,omitempty"`
	PolicyName    *string `xml:"policy_name,omitempty"`
	Status        *string `xml:"status,omitempty"`
	Username      *string `xml:"username,omitempty"`
}

ComputerHistoryPolicyLogsPolicyLogItem represents a computer history policy logs policy log item.

func (ComputerHistoryPolicyLogsPolicyLogItem) MarshalXML 

func (t ComputerHistoryPolicyLogsPolicyLogItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryPolicyLogsPolicyLogItem root element name to the wire value declared by the spec (<policy_log>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryScreenSharingLogs 

type ComputerHistoryScreenSharingLogs struct {
	XMLName          xml.Name
	ScreenSharingLog *[]ComputerHistoryScreenSharingLogsScreenSharingLogItem `xml:"screen_sharing_log,omitempty"`
}

ComputerHistoryScreenSharingLogs represents a computer history screen sharing logs.

func (ComputerHistoryScreenSharingLogs) MarshalXML 

func (t ComputerHistoryScreenSharingLogs) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryScreenSharingLogs root element name to the wire value declared by the spec (<screen_sharing_logs>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryScreenSharingLogsScreenSharingLogItem 

type ComputerHistoryScreenSharingLogsScreenSharingLogItem struct {
	XMLName       xml.Name
	DateTime      *string `xml:"date_time,omitempty"`
	DateTimeEpoch *string `xml:"date_time_epoch,omitempty"`
	DateTimeUtc   *string `xml:"date_time_utc,omitempty"`
	Details       *string `xml:"details,omitempty"`
	Status        *string `xml:"status,omitempty"`
}

ComputerHistoryScreenSharingLogsScreenSharingLogItem represents a computer history screen sharing logs screen sharing log item.

func (ComputerHistoryScreenSharingLogsScreenSharingLogItem) MarshalXML 

func (t ComputerHistoryScreenSharingLogsScreenSharingLogItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryScreenSharingLogsScreenSharingLogItem root element name to the wire value declared by the spec (<screen_sharing_log>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryUserLocation 

type ComputerHistoryUserLocation struct {
	XMLName  xml.Name
	Location *[]ComputerHistoryUserLocationLocationItem `xml:"location,omitempty"`
}

ComputerHistoryUserLocation represents a computer history user location.

func (ComputerHistoryUserLocation) MarshalXML 

func (t ComputerHistoryUserLocation) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryUserLocation root element name to the wire value declared by the spec (<user_location>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerHistoryUserLocationLocationItem 

type ComputerHistoryUserLocationLocationItem struct {
	XMLName       xml.Name
	Building      *string `xml:"building,omitempty"`
	DateTime      *string `xml:"date_time,omitempty"`
	DateTimeEpoch *string `xml:"date_time_epoch,omitempty"`
	DateTimeUtc   *string `xml:"date_time_utc,omitempty"`
	Department    *string `xml:"department,omitempty"`
	EmailAddress  *string `xml:"email_address,omitempty"`
	FullName      *string `xml:"full_name,omitempty"`
	PhoneNumber   *string `xml:"phone_number,omitempty"`
	Position      *string `xml:"position,omitempty"`
	Room          *string `xml:"room,omitempty"`
	Username      *string `xml:"username,omitempty"`
}

ComputerHistoryUserLocationLocationItem represents a computer history user location location item.

func (ComputerHistoryUserLocationLocationItem) MarshalXML 

func (t ComputerHistoryUserLocationLocationItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerHistoryUserLocationLocationItem root element name to the wire value declared by the spec (<location>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerInventoryCollection 

type ComputerInventoryCollection struct {
	XMLName                       xml.Name
	ID                            *int                                     `xml:"id,omitempty"`
	ActiveServices                *bool                                    `xml:"active_services,omitempty"`
	Applications                  *ComputerInventoryCollectionApplications `xml:"applications,omitempty"`
	AvailableSoftwareUpdates      *bool                                    `xml:"available_software_updates,omitempty"`
	ComputerLocationInformation   *bool                                    `xml:"computer_location_information,omitempty"`
	Fonts                         *ComputerInventoryCollectionFonts        `xml:"fonts,omitempty"`
	HiddenAccounts                *bool                                    `xml:"hidden_accounts,omitempty"`
	HomeDirectorySizes            *bool                                    `xml:"home_directory_sizes,omitempty"`
	InclueApplications            *bool                                    `xml:"inclue_applications,omitempty"`
	InclueFonts                   *bool                                    `xml:"inclue_fonts,omitempty"`
	IncluePlugins                 *bool                                    `xml:"inclue_plugins,omitempty"`
	LocalUserAccounts             *bool                                    `xml:"local_user_accounts,omitempty"`
	MobileDeviceAppPurchasingInfo *bool                                    `xml:"mobile_device_app_purchasing_info,omitempty"`
	PackageReceipts               *bool                                    `xml:"package_receipts,omitempty"`
	Plugins                       *ComputerInventoryCollectionPlugins      `xml:"plugins,omitempty"`
	Printers                      *bool                                    `xml:"printers,omitempty"`
}

ComputerInventoryCollection represents a computer inventory collection.

func (ComputerInventoryCollection) MarshalXML 

func (t ComputerInventoryCollection) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerInventoryCollection root element name to the wire value declared by the spec (<computer_inventory_collection>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerInventoryCollectionApplications 

type ComputerInventoryCollectionApplications struct {
	XMLName     xml.Name
	Application *[]ComputerInventoryCollectionApplicationsApplicationItem `xml:"application,omitempty"`
}

ComputerInventoryCollectionApplications represents a computer inventory collection applications.

func (ComputerInventoryCollectionApplications) MarshalXML 

func (t ComputerInventoryCollectionApplications) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerInventoryCollectionApplications root element name to the wire value declared by the spec (<applications>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerInventoryCollectionApplicationsApplicationItem 

type ComputerInventoryCollectionApplicationsApplicationItem struct {
	XMLName xml.Name
	Path    *string `xml:"path,omitempty"`
	// Allowed values: see the ComputerInventoryCollectionApplicationsApplicationItemPlatform constants.
	Platform *string `xml:"platform,omitempty"`
}

ComputerInventoryCollectionApplicationsApplicationItem represents a computer inventory collection applications application item.

func (ComputerInventoryCollectionApplicationsApplicationItem) MarshalXML 

func (t ComputerInventoryCollectionApplicationsApplicationItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerInventoryCollectionApplicationsApplicationItem root element name to the wire value declared by the spec (<application>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerInventoryCollectionApplicationsApplicationItemPlatform 

type ComputerInventoryCollectionApplicationsApplicationItemPlatform = string

ComputerInventoryCollectionApplicationsApplicationItemPlatform is the set of values accepted by ComputerInventoryCollectionApplicationsApplicationItem.Platform. 

const (
	ComputerInventoryCollectionApplicationsApplicationItemPlatformMac     ComputerInventoryCollectionApplicationsApplicationItemPlatform = "Mac"
	ComputerInventoryCollectionApplicationsApplicationItemPlatformWindows ComputerInventoryCollectionApplicationsApplicationItemPlatform = "Windows"
)

ComputerInventoryCollectionApplicationsApplicationItemPlatform 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 ComputerInventoryCollectionApplicationsApplicationItemPlatformValues 

func ComputerInventoryCollectionApplicationsApplicationItemPlatformValues() []ComputerInventoryCollectionApplicationsApplicationItemPlatform

ComputerInventoryCollectionApplicationsApplicationItemPlatformValues returns every value the Jamf API accepts for ComputerInventoryCollectionApplicationsApplicationItemPlatform, 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 ComputerInventoryCollectionFonts 

type ComputerInventoryCollectionFonts struct {
	XMLName xml.Name
	Font    *[]ComputerInventoryCollectionFontsFontItem `xml:"font,omitempty"`
}

ComputerInventoryCollectionFonts represents a computer inventory collection fonts.

func (ComputerInventoryCollectionFonts) MarshalXML 

func (t ComputerInventoryCollectionFonts) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerInventoryCollectionFonts root element name to the wire value declared by the spec (<fonts>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerInventoryCollectionFontsFontItem 

type ComputerInventoryCollectionFontsFontItem struct {
	XMLName xml.Name
	Path    *string `xml:"path,omitempty"`
	// Allowed values: see the ComputerInventoryCollectionFontsFontItemPlatform constants.
	Platform *string `xml:"platform,omitempty"`
}

ComputerInventoryCollectionFontsFontItem represents a computer inventory collection fonts font item.

func (ComputerInventoryCollectionFontsFontItem) MarshalXML 

func (t ComputerInventoryCollectionFontsFontItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerInventoryCollectionFontsFontItem root element name to the wire value declared by the spec (<font>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerInventoryCollectionFontsFontItemPlatform 

type ComputerInventoryCollectionFontsFontItemPlatform = string

ComputerInventoryCollectionFontsFontItemPlatform is the set of values accepted by ComputerInventoryCollectionFontsFontItem.Platform. 

const (
	ComputerInventoryCollectionFontsFontItemPlatformMac     ComputerInventoryCollectionFontsFontItemPlatform = "Mac"
	ComputerInventoryCollectionFontsFontItemPlatformWindows ComputerInventoryCollectionFontsFontItemPlatform = "Windows"
)

ComputerInventoryCollectionFontsFontItemPlatform 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 ComputerInventoryCollectionFontsFontItemPlatformValues 

func ComputerInventoryCollectionFontsFontItemPlatformValues() []ComputerInventoryCollectionFontsFontItemPlatform

ComputerInventoryCollectionFontsFontItemPlatformValues returns every value the Jamf API accepts for ComputerInventoryCollectionFontsFontItemPlatform, 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 ComputerInventoryCollectionPlugins 

type ComputerInventoryCollectionPlugins struct {
	XMLName xml.Name
	Plugin  *[]ComputerInventoryCollectionPluginsPluginItem `xml:"plugin,omitempty"`
}

ComputerInventoryCollectionPlugins represents a computer inventory collection plugins.

func (ComputerInventoryCollectionPlugins) MarshalXML 

func (t ComputerInventoryCollectionPlugins) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerInventoryCollectionPlugins root element name to the wire value declared by the spec (<plugins>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerInventoryCollectionPluginsPluginItem 

type ComputerInventoryCollectionPluginsPluginItem struct {
	XMLName xml.Name
	Path    *string `xml:"path,omitempty"`
	// Allowed values: see the ComputerInventoryCollectionPluginsPluginItemPlatform constants.
	Platform *string `xml:"platform,omitempty"`
}

ComputerInventoryCollectionPluginsPluginItem represents a computer inventory collection plugins plugin item.

func (ComputerInventoryCollectionPluginsPluginItem) MarshalXML 

func (t ComputerInventoryCollectionPluginsPluginItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerInventoryCollectionPluginsPluginItem root element name to the wire value declared by the spec (<plugin>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerInventoryCollectionPluginsPluginItemPlatform 

type ComputerInventoryCollectionPluginsPluginItemPlatform = string

ComputerInventoryCollectionPluginsPluginItemPlatform is the set of values accepted by ComputerInventoryCollectionPluginsPluginItem.Platform. 

const (
	ComputerInventoryCollectionPluginsPluginItemPlatformMac     ComputerInventoryCollectionPluginsPluginItemPlatform = "Mac"
	ComputerInventoryCollectionPluginsPluginItemPlatformWindows ComputerInventoryCollectionPluginsPluginItemPlatform = "Windows"
)

ComputerInventoryCollectionPluginsPluginItemPlatform 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 ComputerInventoryCollectionPluginsPluginItemPlatformValues 

func ComputerInventoryCollectionPluginsPluginItemPlatformValues() []ComputerInventoryCollectionPluginsPluginItemPlatform

ComputerInventoryCollectionPluginsPluginItemPlatformValues returns every value the Jamf API accepts for ComputerInventoryCollectionPluginsPluginItemPlatform, 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 ComputerInvitation 

type ComputerInvitation struct {
	XMLName                     xml.Name
	CreateAccountIfDoesNotExist *bool                             `xml:"create_account_if_does_not_exist,omitempty"`
	EnrollIntoSite              *ComputerInvitationEnrollIntoSite `xml:"enroll_into_site,omitempty"`
	// Use 'Unlimited' to specify no expiration date.
	ExpirationDate             *string     `xml:"expiration_date,omitempty"`
	ExpirationDateEpoch        *BigInt     `xml:"expiration_date_epoch"`
	ExpirationDateUtc          *string     `xml:"expiration_date_utc,omitempty"`
	HideAccount                *bool       `xml:"hide_account,omitempty"`
	ID                         *int        `xml:"id,omitempty"`
	Invitation                 *BigInt     `xml:"invitation"`
	InvitationStatus           *string     `xml:"invitation_status,omitempty"`
	InvitationType             *string     `xml:"invitation_type,omitempty"`
	InvitedUserUUID            *string     `xml:"invited_user_uuid,omitempty"`
	KeepExistingSiteMembership *bool       `xml:"keep_existing_site_membership,omitempty"`
	LockDownSsh                *bool       `xml:"lock_down_ssh,omitempty"`
	MultipleUsesAllowed        *bool       `xml:"multiple_uses_allowed,omitempty"`
	Site                       *SiteObject `xml:"site,omitempty"`
	SshPassword                *string     `xml:"ssh_password,omitempty"`
	SshUsername                *string     `xml:"ssh_username,omitempty"`
	TimesUsed                  *int        `xml:"times_used,omitempty"`
}

ComputerInvitation represents a computer invitation.

func (ComputerInvitation) MarshalXML 

func (t ComputerInvitation) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerInvitation root element name to the wire value declared by the spec (<computer_invitation>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerInvitationEnrollIntoSite 

type ComputerInvitationEnrollIntoSite struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
}

ComputerInvitationEnrollIntoSite represents a computer invitation enroll into site.

func (ComputerInvitationEnrollIntoSite) MarshalXML 

func (t ComputerInvitationEnrollIntoSite) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerInvitationEnrollIntoSite root element name to the wire value declared by the spec (<enroll_into_site>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerInvitations 

type ComputerInvitations struct {
	XMLName             xml.Name
	Size                *Size                                       `xml:"size,omitempty"`
	ComputerInvitations []ComputerInvitationsItemComputerInvitation `xml:"computer_invitation"`
}

ComputerInvitations wraps a Jamf Classic list response with a flat slice of ComputerInvitationsItemComputerInvitation.

func (ComputerInvitations) MarshalXML 

func (t ComputerInvitations) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerInvitations root element name to the wire value declared by the spec (<computer_invitations>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerInvitationsItem 

type ComputerInvitationsItem struct {
	XMLName            xml.Name
	ID                 *int                                       `xml:"id,omitempty"`
	ComputerInvitation *ComputerInvitationsItemComputerInvitation `xml:"computer_invitation,omitempty"`
	Size               *Size                                      `xml:"size,omitempty"`
}

ComputerInvitationsItem represents a computer invitations item.

func (ComputerInvitationsItem) MarshalXML 

func (t ComputerInvitationsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerInvitationsItem root element name to the wire value declared by the spec (<computer_invitation>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerInvitationsItemComputerInvitation 

type ComputerInvitationsItemComputerInvitation struct {
	XMLName             xml.Name
	ExpirationDate      *string `xml:"expiration_date,omitempty"`
	ExpirationDateEpoch *BigInt `xml:"expiration_date_epoch"`
	ExpirationDateUtc   *string `xml:"expiration_date_utc,omitempty"`
	ID                  *int    `xml:"id,omitempty"`
	Invitation          *BigInt `xml:"invitation"`
	InvitationType      *string `xml:"invitation_type,omitempty"`
}

ComputerInvitationsItemComputerInvitation represents a computer invitations item computer invitation.

func (ComputerInvitationsItemComputerInvitation) MarshalXML 

func (t ComputerInvitationsItemComputerInvitation) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerInvitationsItemComputerInvitation root element name to the wire value declared by the spec (<computer_invitation>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerManagement 

type ComputerManagement struct {
	XMLName                      xml.Name
	ID                           *int                                            `xml:"id,omitempty"`
	Ebooks                       *ComputerManagementEbooks                       `xml:"ebooks,omitempty"`
	General                      *ComputerManagementGeneral                      `xml:"general,omitempty"`
	MacAppStoreApps              *ComputerManagementMacAppStoreApps              `xml:"mac_app_store_apps,omitempty"`
	OsXConfigurationProfiles     *ComputerManagementOsXConfigurationProfiles     `xml:"os_x_configuration_profiles,omitempty"`
	PatchPolicies                *ComputerManagementPatchPolicies                `xml:"patch_policies,omitempty"`
	PatchReportingSoftwareTitles *ComputerManagementPatchReportingSoftwareTitles `xml:"patch_reporting_software_titles,omitempty"`
	Policies                     *ComputerManagementPolicies                     `xml:"policies,omitempty"`
	RestrictedSoftware           *ComputerManagementRestrictedSoftware           `xml:"restricted_software,omitempty"`
	SmartGroups                  *ComputerManagementSmartGroups                  `xml:"smart_groups,omitempty"`
	StaticGroups                 *ComputerManagementStaticGroups                 `xml:"static_groups,omitempty"`
}

ComputerManagement represents a computer management.

func (ComputerManagement) MarshalXML 

func (t ComputerManagement) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerManagement root element name to the wire value declared by the spec (<computer_management>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerManagementEbooks 

type ComputerManagementEbooks struct {
	XMLName xml.Name
	Ebook   *[]IDName `xml:"ebook,omitempty"`
}

ComputerManagementEbooks represents a computer management ebooks.

func (ComputerManagementEbooks) MarshalXML 

func (t ComputerManagementEbooks) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerManagementEbooks root element name to the wire value declared by the spec (<ebooks>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerManagementGeneral 

type ComputerManagementGeneral struct {
	XMLName    xml.Name
	ID         *int    `xml:"id,omitempty"`
	MacAddress *string `xml:"mac_address,omitempty"`
	// Name of the computer.
	Name         *string `xml:"name,omitempty"`
	SerialNumber *string `xml:"serial_number,omitempty"`
	UDID         *string `xml:"udid,omitempty"`
}

ComputerManagementGeneral represents a computer management general.

func (ComputerManagementGeneral) MarshalXML 

func (t ComputerManagementGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerManagementGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerManagementMacAppStoreApps 

type ComputerManagementMacAppStoreApps struct {
	XMLName        xml.Name
	MacAppStoreApp *[]IDName `xml:"mac_app_store_app,omitempty"`
}

ComputerManagementMacAppStoreApps represents a computer management mac app store apps.

func (ComputerManagementMacAppStoreApps) MarshalXML 

func (t ComputerManagementMacAppStoreApps) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerManagementMacAppStoreApps root element name to the wire value declared by the spec (<mac_app_store_apps>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerManagementOsXConfigurationProfiles 

type ComputerManagementOsXConfigurationProfiles struct {
	XMLName xml.Name
	Profile *[]IDName `xml:"profile,omitempty"`
}

ComputerManagementOsXConfigurationProfiles represents a computer management os x configuration profiles.

func (ComputerManagementOsXConfigurationProfiles) MarshalXML 

func (t ComputerManagementOsXConfigurationProfiles) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerManagementOsXConfigurationProfiles root element name to the wire value declared by the spec (<os_x_configuration_profiles>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerManagementPatchPolicies 

type ComputerManagementPatchPolicies struct {
	XMLName     xml.Name
	PatchPolicy *[]IDName `xml:"patch_policy,omitempty"`
}

ComputerManagementPatchPolicies represents a computer management patch policies.

func (ComputerManagementPatchPolicies) MarshalXML 

func (t ComputerManagementPatchPolicies) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerManagementPatchPolicies root element name to the wire value declared by the spec (<patch_policies>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerManagementPatchReportingSoftwareTitles 

type ComputerManagementPatchReportingSoftwareTitles struct {
	XMLName xml.Name
	Title   *[]ComputerManagementPatchReportingSoftwareTitlesTitleItem `xml:"title,omitempty"`
}

ComputerManagementPatchReportingSoftwareTitles represents a computer management patch reporting software titles.

func (ComputerManagementPatchReportingSoftwareTitles) MarshalXML 

func (t ComputerManagementPatchReportingSoftwareTitles) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerManagementPatchReportingSoftwareTitles root element name to the wire value declared by the spec (<patch_reporting_software_titles>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerManagementPatchReportingSoftwareTitlesTitleItem 

type ComputerManagementPatchReportingSoftwareTitlesTitleItem struct {
	XMLName          xml.Name
	InstalledVersion *string `xml:"installed_version,omitempty"`
	LatestVersion    *string `xml:"latest_version,omitempty"`
	Name             *string `xml:"name,omitempty"`
}

ComputerManagementPatchReportingSoftwareTitlesTitleItem represents a computer management patch reporting software titles title item.

func (ComputerManagementPatchReportingSoftwareTitlesTitleItem) MarshalXML 

func (t ComputerManagementPatchReportingSoftwareTitlesTitleItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerManagementPatchReportingSoftwareTitlesTitleItem root element name to the wire value declared by the spec (<title>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerManagementPolicies 

type ComputerManagementPolicies struct {
	XMLName xml.Name
	Policy  *[]ComputerManagementPoliciesPolicyItem `xml:"policy,omitempty"`
}

ComputerManagementPolicies represents a computer management policies.

func (ComputerManagementPolicies) MarshalXML 

func (t ComputerManagementPolicies) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerManagementPolicies root element name to the wire value declared by the spec (<policies>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerManagementPoliciesPolicyItem 

type ComputerManagementPoliciesPolicyItem struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
	Trigger *string `xml:"trigger,omitempty"`
}

ComputerManagementPoliciesPolicyItem represents a computer management policies policy item.

func (ComputerManagementPoliciesPolicyItem) MarshalXML 

func (t ComputerManagementPoliciesPolicyItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerManagementPoliciesPolicyItem root element name to the wire value declared by the spec (<policy>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerManagementRestrictedSoftware 

type ComputerManagementRestrictedSoftware struct {
	XMLName  xml.Name
	Software *[]IDName `xml:"software,omitempty"`
}

ComputerManagementRestrictedSoftware represents a computer management restricted software.

func (ComputerManagementRestrictedSoftware) MarshalXML 

func (t ComputerManagementRestrictedSoftware) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerManagementRestrictedSoftware root element name to the wire value declared by the spec (<restricted_software>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerManagementSmartGroups 

type ComputerManagementSmartGroups struct {
	XMLName xml.Name
	Group   *[]IDName `xml:"group,omitempty"`
}

ComputerManagementSmartGroups represents a computer management smart groups.

func (ComputerManagementSmartGroups) MarshalXML 

func (t ComputerManagementSmartGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerManagementSmartGroups root element name to the wire value declared by the spec (<smart_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerManagementStaticGroups 

type ComputerManagementStaticGroups struct {
	XMLName xml.Name
	Group   *[]IDName `xml:"group,omitempty"`
}

ComputerManagementStaticGroups represents a computer management static groups.

func (ComputerManagementStaticGroups) MarshalXML 

func (t ComputerManagementStaticGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerManagementStaticGroups root element name to the wire value declared by the spec (<static_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPost 

type ComputerPost struct {
	XMLName               xml.Name
	ID                    *int                               `xml:"id,omitempty"`
	Certificates          *ComputerPostCertificates          `xml:"certificates,omitempty"`
	ConfigurationProfiles *ComputerPostConfigurationProfiles `xml:"configuration_profiles,omitempty"`
	ExtensionAttributes   *ComputerPostExtensionAttributes   `xml:"extension_attributes,omitempty"`
	General               *ComputerPostGeneral               `xml:"general,omitempty"`
	GroupsAccounts        *ComputerPostGroupsAccounts        `xml:"groups_accounts,omitempty"`
	Hardware              *ComputerPostHardware              `xml:"hardware,omitempty"`
	Location              *Location                          `xml:"location,omitempty"`
	Peripherals           *ComputerPostPeripherals           `xml:"peripherals,omitempty"`
	Purchasing            *Purchasing                        `xml:"purchasing,omitempty"`
	Security              *ComputerPostSecurity              `xml:"security,omitempty"`
	Software              *ComputerPostSoftware              `xml:"software,omitempty"`
}

ComputerPost represents a computer post.

func (ComputerPost) MarshalXML 

func (t ComputerPost) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPost root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostCertificates 

type ComputerPostCertificates struct {
	XMLName     xml.Name
	Certificate *[]ComputerPostCertificatesCertificateItem `xml:"certificate,omitempty"`
}

ComputerPostCertificates represents a computer post certificates.

func (ComputerPostCertificates) MarshalXML 

func (t ComputerPostCertificates) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostCertificates root element name to the wire value declared by the spec (<certificates>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostCertificatesCertificateItem 

type ComputerPostCertificatesCertificateItem struct {
	XMLName      xml.Name
	CommonName   *string `xml:"common_name,omitempty"`
	ExpiresEpoch *int    `xml:"expires_epoch,omitempty"`
	ExpiresUtc   *string `xml:"expires_utc,omitempty"`
	Identify     *bool   `xml:"identify,omitempty"`
	Name         *string `xml:"name,omitempty"`
}

ComputerPostCertificatesCertificateItem represents a computer post certificates certificate item.

func (ComputerPostCertificatesCertificateItem) MarshalXML 

func (t ComputerPostCertificatesCertificateItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostCertificatesCertificateItem root element name to the wire value declared by the spec (<certificate>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostConfigurationProfiles 

type ComputerPostConfigurationProfiles struct {
	XMLName              xml.Name
	ConfigurationProfile *[]ComputerPostConfigurationProfilesConfigurationProfileItem `xml:"configuration_profile,omitempty"`
	Size                 *Size                                                        `xml:"size,omitempty"`
}

ComputerPostConfigurationProfiles represents a computer post configuration profiles.

func (ComputerPostConfigurationProfiles) MarshalXML 

func (t ComputerPostConfigurationProfiles) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostConfigurationProfiles root element name to the wire value declared by the spec (<configuration_profiles>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostConfigurationProfilesConfigurationProfileItem 

type ComputerPostConfigurationProfilesConfigurationProfileItem struct {
	XMLName     xml.Name
	ID          *int    `xml:"id,omitempty"`
	IsRemovable *bool   `xml:"is_removable,omitempty"`
	Name        *string `xml:"name,omitempty"`
	UUID        *string `xml:"uuid,omitempty"`
}

ComputerPostConfigurationProfilesConfigurationProfileItem represents a computer post configuration profiles configuration profile item.

func (ComputerPostConfigurationProfilesConfigurationProfileItem) MarshalXML 

func (t ComputerPostConfigurationProfilesConfigurationProfileItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostConfigurationProfilesConfigurationProfileItem root element name to the wire value declared by the spec (<configuration_profile>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostExtensionAttributes 

type ComputerPostExtensionAttributes struct {
	XMLName            xml.Name
	ExtensionAttribute *[]ComputerPostExtensionAttributesExtensionAttributeItem `xml:"extension_attribute,omitempty"`
}

ComputerPostExtensionAttributes represents a computer post extension attributes.

func (ComputerPostExtensionAttributes) MarshalXML 

func (t ComputerPostExtensionAttributes) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostExtensionAttributes root element name to the wire value declared by the spec (<extension_attributes>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostExtensionAttributesExtensionAttributeItem 

type ComputerPostExtensionAttributesExtensionAttributeItem struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
	Type    *string `xml:"type,omitempty"`
	Value   *string `xml:"value,omitempty"`
}

ComputerPostExtensionAttributesExtensionAttributeItem represents a computer post extension attributes extension attribute item.

func (ComputerPostExtensionAttributesExtensionAttributeItem) MarshalXML 

func (t ComputerPostExtensionAttributesExtensionAttributeItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostExtensionAttributesExtensionAttributeItem root element name to the wire value declared by the spec (<extension_attribute>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostGeneral 

type ComputerPostGeneral struct {
	XMLName                    xml.Name
	AltMacAddress              *string                              `xml:"alt_mac_address,omitempty"`
	AltNetworkAdapterType      *string                              `xml:"alt_network_adapter_type,omitempty"`
	AssetTag                   *string                              `xml:"asset_tag,omitempty"`
	Barcode1                   *string                              `xml:"barcode_1,omitempty"`
	Barcode2                   *string                              `xml:"barcode_2,omitempty"`
	DistributionPoint          *string                              `xml:"distribution_point,omitempty"`
	ID                         *int                                 `xml:"id,omitempty"`
	InitialEntryDate           *string                              `xml:"initial_entry_date,omitempty"`
	InitialEntryDateEpoch      *int                                 `xml:"initial_entry_date_epoch,omitempty"`
	InitialEntryDateUtc        *string                              `xml:"initial_entry_date_utc,omitempty"`
	IPAddress                  *string                              `xml:"ip_address,omitempty"`
	ItunesStoreAccountIsActive *bool                                `xml:"itunes_store_account_is_active,omitempty"`
	JamfVersion                *string                              `xml:"jamf_version,omitempty"`
	LastCloudBackupDateEpoch   *int                                 `xml:"last_cloud_backup_date_epoch,omitempty"`
	LastCloudBackupDateUtc     *string                              `xml:"last_cloud_backup_date_utc,omitempty"`
	LastContactTime            *string                              `xml:"last_contact_time,omitempty"`
	LastContactTimeEpoch       *int                                 `xml:"last_contact_time_epoch,omitempty"`
	LastContactTimeUtc         *string                              `xml:"last_contact_time_utc,omitempty"`
	LastEnrolledDateEpoch      *int                                 `xml:"last_enrolled_date_epoch,omitempty"`
	LastEnrolledDateUtc        *string                              `xml:"last_enrolled_date_utc,omitempty"`
	LastReportedIp             *string                              `xml:"last_reported_ip,omitempty"`
	MacAddress                 *string                              `xml:"mac_address,omitempty"`
	ManagementStatus           *ComputerPostGeneralManagementStatus `xml:"management_status,omitempty"`
	MDMCapable                 *bool                                `xml:"mdm_capable,omitempty"`
	MDMCapableUsers            *ComputerPostGeneralMDMCapableUsers  `xml:"mdm_capable_users,omitempty"`
	// Name of computer.
	Name               *string                              `xml:"name,omitempty"`
	NetworkAdapterType *string                              `xml:"network_adapter_type,omitempty"`
	Platform           *string                              `xml:"platform,omitempty"`
	RemoteManagement   *ComputerPostGeneralRemoteManagement `xml:"remote_management,omitempty"`
	ReportDate         *string                              `xml:"report_date,omitempty"`
	ReportDateEpoch    *int                                 `xml:"report_date_epoch,omitempty"`
	ReportDateUtc      *string                              `xml:"report_date_utc,omitempty"`
	SerialNumber       *string                              `xml:"serial_number,omitempty"`
	Site               *SiteObject                          `xml:"site,omitempty"`
	Sus                *string                              `xml:"sus,omitempty"`
	UDID               *string                              `xml:"udid,omitempty"`
}

ComputerPostGeneral represents a computer post general.

func (ComputerPostGeneral) MarshalXML 

func (t ComputerPostGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostGeneralMDMCapableUsers 

type ComputerPostGeneralMDMCapableUsers struct {
	XMLName        xml.Name
	MDMCapableUser *string `xml:"mdm_capable_user,omitempty"`
}

ComputerPostGeneralMDMCapableUsers represents a computer post general m d m capable users.

func (ComputerPostGeneralMDMCapableUsers) MarshalXML 

func (t ComputerPostGeneralMDMCapableUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostGeneralMDMCapableUsers root element name to the wire value declared by the spec (<mdm_capable_users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostGeneralManagementStatus 

type ComputerPostGeneralManagementStatus struct {
	XMLName                xml.Name
	EnrolledViaDep         *bool `xml:"enrolled_via_dep,omitempty"`
	UserApprovedEnrollment *bool `xml:"user_approved_enrollment,omitempty"`
	UserApprovedMDM        *bool `xml:"user_approved_mdm,omitempty"`
}

ComputerPostGeneralManagementStatus represents a computer post general management status.

func (ComputerPostGeneralManagementStatus) MarshalXML 

func (t ComputerPostGeneralManagementStatus) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostGeneralManagementStatus root element name to the wire value declared by the spec (<management_status>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostGeneralRemoteManagement 

type ComputerPostGeneralRemoteManagement struct {
	XMLName            xml.Name
	Managed            *bool   `xml:"managed,omitempty"`
	ManagementUsername *string `xml:"management_username,omitempty"`
}

ComputerPostGeneralRemoteManagement represents a computer post general remote management.

func (ComputerPostGeneralRemoteManagement) MarshalXML 

func (t ComputerPostGeneralRemoteManagement) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostGeneralRemoteManagement root element name to the wire value declared by the spec (<remote_management>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostGroupsAccounts 

type ComputerPostGroupsAccounts struct {
	XMLName                  xml.Name
	ID                       *int                                                      `xml:"id,omitempty"`
	ComputerGroupMemberships *[]ComputerPostGroupsAccountsComputerGroupMembershipsItem `xml:"computer_group_memberships,omitempty"`
	LocalAccounts            *ComputerPostGroupsAccountsLocalAccounts                  `xml:"local_accounts,omitempty"`
}

ComputerPostGroupsAccounts represents a computer post groups accounts.

func (ComputerPostGroupsAccounts) MarshalXML 

func (t ComputerPostGroupsAccounts) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostGroupsAccounts root element name to the wire value declared by the spec (<groups_accounts>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostGroupsAccountsComputerGroupMembershipsItem 

type ComputerPostGroupsAccountsComputerGroupMembershipsItem struct {
	Group *string `xml:"group,omitempty"`
}

ComputerPostGroupsAccountsComputerGroupMembershipsItem represents a computer post groups accounts computer group memberships item.

type ComputerPostGroupsAccountsLocalAccounts 

type ComputerPostGroupsAccountsLocalAccounts struct {
	XMLName xml.Name
	User    *[]ComputerPostGroupsAccountsLocalAccountsUserItem `xml:"user,omitempty"`
}

ComputerPostGroupsAccountsLocalAccounts represents a computer post groups accounts local accounts.

func (ComputerPostGroupsAccountsLocalAccounts) MarshalXML 

func (t ComputerPostGroupsAccountsLocalAccounts) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostGroupsAccountsLocalAccounts root element name to the wire value declared by the spec (<local_accounts>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostGroupsAccountsLocalAccountsUserItem 

type ComputerPostGroupsAccountsLocalAccountsUserItem struct {
	XMLName          xml.Name
	Administrator    *bool   `xml:"administrator,omitempty"`
	FilevaultEnabled *bool   `xml:"filevault_enabled,omitempty"`
	Home             *string `xml:"home,omitempty"`
	HomeSize         *string `xml:"home_size,omitempty"`
	HomeSizeMb       *string `xml:"home_size_mb,omitempty"`
	Name             *string `xml:"name,omitempty"`
	Realname         *string `xml:"realname,omitempty"`
	Uid              *string `xml:"uid,omitempty"`
}

ComputerPostGroupsAccountsLocalAccountsUserItem represents a computer post groups accounts local accounts user item.

func (ComputerPostGroupsAccountsLocalAccountsUserItem) MarshalXML 

func (t ComputerPostGroupsAccountsLocalAccountsUserItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostGroupsAccountsLocalAccountsUserItem root element name to the wire value declared by the spec (<user>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostHardware 

type ComputerPostHardware struct {
	XMLName                     xml.Name
	ID                          *int                                       `xml:"id,omitempty"`
	ActiveDirectoryStatus       *string                                    `xml:"active_directory_status,omitempty"`
	AvailableRamSlots           *int                                       `xml:"available_ram_slots,omitempty"`
	BatteryCapacity             *int                                       `xml:"battery_capacity,omitempty"`
	BleCapable                  *bool                                      `xml:"ble_capable,omitempty"`
	BootRom                     *string                                    `xml:"boot_rom,omitempty"`
	BusSpeed                    *int                                       `xml:"bus_speed,omitempty"`
	BusSpeedMhz                 *int                                       `xml:"bus_speed_mhz,omitempty"`
	CacheSize                   *int                                       `xml:"cache_size,omitempty"`
	CacheSizeKb                 *int                                       `xml:"cache_size_kb,omitempty"`
	DiskEncryptionConfiguration *string                                    `xml:"disk_encryption_configuration,omitempty"`
	Filevault2Users             *[]ComputerPostHardwareFilevault2UsersItem `xml:"filevault_2_users,omitempty"`
	GatekeeperStatus            *string                                    `xml:"gatekeeper_status,omitempty"`
	InstitutionalRecoveryKey    *string                                    `xml:"institutional_recovery_key,omitempty"`
	Make                        *string                                    `xml:"make,omitempty"`
	MappedPrinters              *ComputerPostHardwareMappedPrinters        `xml:"mapped_printers,omitempty"`
	MasterPasswordSet           *bool                                      `xml:"master_password_set,omitempty"`
	Model                       *string                                    `xml:"model,omitempty"`
	ModelIdentifier             *string                                    `xml:"model_identifier,omitempty"`
	NicSpeed                    *string                                    `xml:"nic_speed,omitempty"`
	NumberCores                 *int                                       `xml:"number_cores,omitempty"`
	NumberProcessors            *int                                       `xml:"number_processors,omitempty"`
	OpticalDrive                *string                                    `xml:"optical_drive,omitempty"`
	OsBuild                     *string                                    `xml:"os_build,omitempty"`
	OsName                      *string                                    `xml:"os_name,omitempty"`
	OsVersion                   *string                                    `xml:"os_version,omitempty"`
	ProcessorArchitechture      *string                                    `xml:"processor_architechture,omitempty"`
	ProcessorSpeed              *string                                    `xml:"processor_speed,omitempty"`
	ProcessorSpeedMhz           *string                                    `xml:"processor_speed_mhz,omitempty"`
	ProcessorType               *string                                    `xml:"processor_type,omitempty"`
	ServicePack                 *string                                    `xml:"service_pack,omitempty"`
	// Allowed values: see the ComputerPostHardwareSipStatus constants.
	SipStatus       *string                      `xml:"sip_status,omitempty"`
	SmcVersion      *string                      `xml:"smc_version,omitempty"`
	Storage         *ComputerPostHardwareStorage `xml:"storage,omitempty"`
	TotalRam        *int                         `xml:"total_ram,omitempty"`
	TotalRamMb      *int                         `xml:"total_ram_mb,omitempty"`
	XprotectVersion *string                      `xml:"xprotect_version,omitempty"`
}

ComputerPostHardware represents a computer post hardware.

func (ComputerPostHardware) MarshalXML 

func (t ComputerPostHardware) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostHardware root element name to the wire value declared by the spec (<hardware>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostHardwareFilevault2UsersItem 

type ComputerPostHardwareFilevault2UsersItem struct {
	User *string `xml:"user,omitempty"`
}

ComputerPostHardwareFilevault2UsersItem represents a computer post hardware filevault2 users item.

type ComputerPostHardwareMappedPrinters 

type ComputerPostHardwareMappedPrinters struct {
	XMLName xml.Name
	Printer *[]ComputerPostHardwareMappedPrintersPrinterItem `xml:"printer,omitempty"`
}

ComputerPostHardwareMappedPrinters represents a computer post hardware mapped printers.

func (ComputerPostHardwareMappedPrinters) MarshalXML 

func (t ComputerPostHardwareMappedPrinters) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostHardwareMappedPrinters root element name to the wire value declared by the spec (<mapped_printers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostHardwareMappedPrintersPrinterItem 

type ComputerPostHardwareMappedPrintersPrinterItem struct {
	XMLName  xml.Name
	Location *string `xml:"location,omitempty"`
	Name     *string `xml:"name,omitempty"`
	Type     *string `xml:"type,omitempty"`
	URI      *string `xml:"uri,omitempty"`
}

ComputerPostHardwareMappedPrintersPrinterItem represents a computer post hardware mapped printers printer item.

func (ComputerPostHardwareMappedPrintersPrinterItem) MarshalXML 

func (t ComputerPostHardwareMappedPrintersPrinterItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostHardwareMappedPrintersPrinterItem root element name to the wire value declared by the spec (<printer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostHardwareSipStatus 

type ComputerPostHardwareSipStatus = string

ComputerPostHardwareSipStatus is the set of values accepted by ComputerPostHardware.SipStatus. 

const (
	ComputerPostHardwareSipStatusEnabled  ComputerPostHardwareSipStatus = "Enabled"
	ComputerPostHardwareSipStatusDisabled ComputerPostHardwareSipStatus = "Disabled"
)

ComputerPostHardwareSipStatus 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 ComputerPostHardwareSipStatusValues 

func ComputerPostHardwareSipStatusValues() []ComputerPostHardwareSipStatus

ComputerPostHardwareSipStatusValues returns every value the Jamf API accepts for ComputerPostHardwareSipStatus, 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 ComputerPostHardwareStorage 

type ComputerPostHardwareStorage struct {
	XMLName xml.Name
	Device  *[]ComputerPostHardwareStorageDeviceItem `xml:"device,omitempty"`
}

ComputerPostHardwareStorage represents a computer post hardware storage.

func (ComputerPostHardwareStorage) MarshalXML 

func (t ComputerPostHardwareStorage) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostHardwareStorage root element name to the wire value declared by the spec (<storage>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostHardwareStorageDeviceItem 

type ComputerPostHardwareStorageDeviceItem struct {
	XMLName         xml.Name
	ConnectionType  *string                                               `xml:"connection_type,omitempty"`
	Disk            *string                                               `xml:"disk,omitempty"`
	DriveCapacityMb *int                                                  `xml:"drive_capacity_mb,omitempty"`
	Model           *string                                               `xml:"model,omitempty"`
	Partition       *[]ComputerPostHardwareStorageDeviceItemPartitionItem `xml:"partition,omitempty"`
	Revision        *string                                               `xml:"revision,omitempty"`
	SerialNumber    *string                                               `xml:"serial_number,omitempty"`
	Size            *int                                                  `xml:"size,omitempty"`
	SmartStatus     *string                                               `xml:"smart_status,omitempty"`
}

ComputerPostHardwareStorageDeviceItem represents a computer post hardware storage device item.

func (ComputerPostHardwareStorageDeviceItem) MarshalXML 

func (t ComputerPostHardwareStorageDeviceItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostHardwareStorageDeviceItem root element name to the wire value declared by the spec (<device>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostHardwareStorageDeviceItemPartitionItem 

type ComputerPostHardwareStorageDeviceItemPartitionItem struct {
	XMLName              xml.Name
	BootDriveAvailableMb *int    `xml:"boot_drive_available_mb,omitempty"`
	Filevault2Percent    *int    `xml:"filevault2_percent,omitempty"`
	Filevault2Status     *string `xml:"filevault2_status,omitempty"`
	FilevaultPercent     *int    `xml:"filevault_percent,omitempty"`
	FilevaultStatus      *string `xml:"filevault_status,omitempty"`
	LvUUID               *string `xml:"lvUUID,omitempty"`
	LvgUUID              *string `xml:"lvgUUID,omitempty"`
	Name                 *string `xml:"name,omitempty"`
	PartitionCapacityMb  *int    `xml:"partition_capacity_mb,omitempty"`
	PercentageFull       *int    `xml:"percentage_full,omitempty"`
	PvUUID               *string `xml:"pvUUID,omitempty"`
	Size                 *int    `xml:"size,omitempty"`
	Type                 *string `xml:"type,omitempty"`
}

ComputerPostHardwareStorageDeviceItemPartitionItem represents a computer post hardware storage device item partition item.

func (ComputerPostHardwareStorageDeviceItemPartitionItem) MarshalXML 

func (t ComputerPostHardwareStorageDeviceItemPartitionItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostHardwareStorageDeviceItemPartitionItem root element name to the wire value declared by the spec (<partition>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostPeripherals 

type ComputerPostPeripherals struct {
	XMLName     xml.Name
	Peripherals *[]ComputerPostPeripheralsPeripheralsItem `xml:"peripherals,omitempty"`
	Size        *Size                                     `xml:"size,omitempty"`
}

ComputerPostPeripherals represents a computer post peripherals.

func (ComputerPostPeripherals) MarshalXML 

func (t ComputerPostPeripherals) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostPeripherals root element name to the wire value declared by the spec (<peripherals>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostPeripheralsPeripheralsItem 

type ComputerPostPeripheralsPeripheralsItem struct {
	ID          *int                                               `xml:"id,omitempty"`
	Attachments *ComputerPostPeripheralsPeripheralsItemAttachments `xml:"attachments,omitempty"`
	Peripheral  *ComputerPostPeripheralsPeripheralsItemPeripheral  `xml:"peripheral,omitempty"`
	Purchasing  *Purchasing                                        `xml:"purchasing,omitempty"`
}

ComputerPostPeripheralsPeripheralsItem represents a computer post peripherals peripherals item.

type ComputerPostPeripheralsPeripheralsItemAttachments 

type ComputerPostPeripheralsPeripheralsItemAttachments struct {
	XMLName    xml.Name
	Attachment *[]Attachment `xml:"attachment,omitempty"`
	Size       *Size         `xml:"size,omitempty"`
}

ComputerPostPeripheralsPeripheralsItemAttachments represents a computer post peripherals peripherals item attachments.

func (ComputerPostPeripheralsPeripheralsItemAttachments) MarshalXML 

func (t ComputerPostPeripheralsPeripheralsItemAttachments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostPeripheralsPeripheralsItemAttachments root element name to the wire value declared by the spec (<attachments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostPeripheralsPeripheralsItemPeripheral 

type ComputerPostPeripheralsPeripheralsItemPeripheral struct {
	XMLName  xml.Name
	BarCode1 *string                                                 `xml:"bar_code_1,omitempty"`
	BarCode2 *string                                                 `xml:"bar_code_2,omitempty"`
	Fields   *ComputerPostPeripheralsPeripheralsItemPeripheralFields `xml:"fields,omitempty"`
	ID       *int                                                    `xml:"id,omitempty"`
	// Name of the peripheral type.
	Type *string `xml:"type,omitempty"`
}

ComputerPostPeripheralsPeripheralsItemPeripheral represents a computer post peripherals peripherals item peripheral.

func (ComputerPostPeripheralsPeripheralsItemPeripheral) MarshalXML 

func (t ComputerPostPeripheralsPeripheralsItemPeripheral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostPeripheralsPeripheralsItemPeripheral root element name to the wire value declared by the spec (<peripheral>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostPeripheralsPeripheralsItemPeripheralFields 

type ComputerPostPeripheralsPeripheralsItemPeripheralFields struct {
	XMLName xml.Name
	ID      *int                                                         `xml:"id,omitempty"`
	Field   *ComputerPostPeripheralsPeripheralsItemPeripheralFieldsField `xml:"field,omitempty"`
}

ComputerPostPeripheralsPeripheralsItemPeripheralFields represents a computer post peripherals peripherals item peripheral fields.

func (ComputerPostPeripheralsPeripheralsItemPeripheralFields) MarshalXML 

func (t ComputerPostPeripheralsPeripheralsItemPeripheralFields) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostPeripheralsPeripheralsItemPeripheralFields root element name to the wire value declared by the spec (<fields>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostPeripheralsPeripheralsItemPeripheralFieldsField 

type ComputerPostPeripheralsPeripheralsItemPeripheralFieldsField struct {
	XMLName xml.Name
	Name    *string `xml:"name,omitempty"`
	Value   *string `xml:"value,omitempty"`
}

ComputerPostPeripheralsPeripheralsItemPeripheralFieldsField represents a computer post peripherals peripherals item peripheral fields field.

func (ComputerPostPeripheralsPeripheralsItemPeripheralFieldsField) MarshalXML 

func (t ComputerPostPeripheralsPeripheralsItemPeripheralFieldsField) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostPeripheralsPeripheralsItemPeripheralFieldsField root element name to the wire value declared by the spec (<field>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostSecurity 

type ComputerPostSecurity struct {
	XMLName             xml.Name
	ActivationLock      *bool   `xml:"activation_lock,omitempty"`
	ExternalBootLevel   *string `xml:"external_boot_level,omitempty"`
	FirewallEnabled     *bool   `xml:"firewall_enabled,omitempty"`
	RecoveryLockEnabled *bool   `xml:"recovery_lock_enabled,omitempty"`
	SecureBootLevel     *string `xml:"secure_boot_level,omitempty"`
}

ComputerPostSecurity represents a computer post security.

func (ComputerPostSecurity) MarshalXML 

func (t ComputerPostSecurity) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostSecurity root element name to the wire value declared by the spec (<security>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostSoftware 

type ComputerPostSoftware struct {
	XMLName                  xml.Name
	ID                       *int                                                `xml:"id,omitempty"`
	Applications             *ComputerPostSoftwareApplications                   `xml:"applications,omitempty"`
	AvailableSoftwareUpdates *[]ComputerPostSoftwareAvailableSoftwareUpdatesItem `xml:"available_software_updates,omitempty"`
	AvailableUpdates         *ComputerPostSoftwareAvailableUpdates               `xml:"available_updates,omitempty"`
	CachedByCasper           *[]ComputerPostSoftwareCachedByCasperItem           `xml:"cached_by_casper,omitempty"`
	Fonts                    *ComputerPostSoftwareFonts                          `xml:"fonts,omitempty"`
	InstalledByCasper        *[]ComputerPostSoftwareInstalledByCasperItem        `xml:"installed_by_casper,omitempty"`
	InstalledByInstallerSwu  *[]ComputerPostSoftwareInstalledByInstallerSwuItem  `xml:"installed_by_installer_swu,omitempty"`
	LicensedSoftware         *[]ComputerPostSoftwareLicensedSoftwareItem         `xml:"licensed_software,omitempty"`
	Plugins                  *ComputerPostSoftwarePlugins                        `xml:"plugins,omitempty"`
	RunningServices          *[]ComputerPostSoftwareRunningServicesItem          `xml:"running_services,omitempty"`
	UnixExecutables          *string                                             `xml:"unix_executables,omitempty"`
}

ComputerPostSoftware represents a computer post software.

func (ComputerPostSoftware) MarshalXML 

func (t ComputerPostSoftware) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostSoftware root element name to the wire value declared by the spec (<software>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostSoftwareApplications 

type ComputerPostSoftwareApplications struct {
	XMLName     xml.Name
	Application *[]ComputerPostSoftwareApplicationsApplicationItem `xml:"application,omitempty"`
	Size        *Size                                              `xml:"size,omitempty"`
}

ComputerPostSoftwareApplications represents a computer post software applications.

func (ComputerPostSoftwareApplications) MarshalXML 

func (t ComputerPostSoftwareApplications) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostSoftwareApplications root element name to the wire value declared by the spec (<applications>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostSoftwareApplicationsApplicationItem 

type ComputerPostSoftwareApplicationsApplicationItem struct {
	XMLName xml.Name
	Name    *string `xml:"name,omitempty"`
	Path    *string `xml:"path,omitempty"`
	Version *string `xml:"version,omitempty"`
}

ComputerPostSoftwareApplicationsApplicationItem represents a computer post software applications application item.

func (ComputerPostSoftwareApplicationsApplicationItem) MarshalXML 

func (t ComputerPostSoftwareApplicationsApplicationItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostSoftwareApplicationsApplicationItem root element name to the wire value declared by the spec (<application>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostSoftwareAvailableSoftwareUpdatesItem 

type ComputerPostSoftwareAvailableSoftwareUpdatesItem struct {
	Name *string `xml:"name,omitempty"`
}

ComputerPostSoftwareAvailableSoftwareUpdatesItem represents a computer post software available software updates item.

type ComputerPostSoftwareAvailableUpdates 

type ComputerPostSoftwareAvailableUpdates struct {
	XMLName xml.Name
	Update  *[]ComputerPostSoftwareAvailableUpdatesUpdateItem `xml:"update,omitempty"`
}

ComputerPostSoftwareAvailableUpdates represents a computer post software available updates.

func (ComputerPostSoftwareAvailableUpdates) MarshalXML 

func (t ComputerPostSoftwareAvailableUpdates) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostSoftwareAvailableUpdates root element name to the wire value declared by the spec (<available_updates>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostSoftwareAvailableUpdatesUpdateItem 

type ComputerPostSoftwareAvailableUpdatesUpdateItem struct {
	XMLName     xml.Name
	Name        *string `xml:"name,omitempty"`
	PackageName *string `xml:"package_name,omitempty"`
	Version     *string `xml:"version,omitempty"`
}

ComputerPostSoftwareAvailableUpdatesUpdateItem represents a computer post software available updates update item.

func (ComputerPostSoftwareAvailableUpdatesUpdateItem) MarshalXML 

func (t ComputerPostSoftwareAvailableUpdatesUpdateItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostSoftwareAvailableUpdatesUpdateItem root element name to the wire value declared by the spec (<update>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostSoftwareCachedByCasperItem 

type ComputerPostSoftwareCachedByCasperItem struct {
	XMLName xml.Name
	Package *string `xml:"package,omitempty"`
}

ComputerPostSoftwareCachedByCasperItem represents a computer post software cached by casper item.

func (ComputerPostSoftwareCachedByCasperItem) MarshalXML 

func (t ComputerPostSoftwareCachedByCasperItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostSoftwareCachedByCasperItem root element name to the wire value declared by the spec (<cached_by_casper>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostSoftwareFonts 

type ComputerPostSoftwareFonts struct {
	XMLName xml.Name
	Font    *[]ComputerPostSoftwareFontsFontItem `xml:"font,omitempty"`
	Size    *Size                                `xml:"size,omitempty"`
}

ComputerPostSoftwareFonts represents a computer post software fonts.

func (ComputerPostSoftwareFonts) MarshalXML 

func (t ComputerPostSoftwareFonts) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostSoftwareFonts root element name to the wire value declared by the spec (<fonts>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostSoftwareFontsFontItem 

type ComputerPostSoftwareFontsFontItem struct {
	XMLName xml.Name
	Name    *string `xml:"name,omitempty"`
	Path    *string `xml:"path,omitempty"`
	Version *string `xml:"version,omitempty"`
}

ComputerPostSoftwareFontsFontItem represents a computer post software fonts font item.

func (ComputerPostSoftwareFontsFontItem) MarshalXML 

func (t ComputerPostSoftwareFontsFontItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostSoftwareFontsFontItem root element name to the wire value declared by the spec (<font>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostSoftwareInstalledByCasperItem 

type ComputerPostSoftwareInstalledByCasperItem struct {
	XMLName xml.Name
	Package *string `xml:"package,omitempty"`
}

ComputerPostSoftwareInstalledByCasperItem represents a computer post software installed by casper item.

func (ComputerPostSoftwareInstalledByCasperItem) MarshalXML 

func (t ComputerPostSoftwareInstalledByCasperItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostSoftwareInstalledByCasperItem root element name to the wire value declared by the spec (<installed_by_casper>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostSoftwareInstalledByInstallerSwuItem 

type ComputerPostSoftwareInstalledByInstallerSwuItem struct {
	XMLName xml.Name
	Package *string `xml:"package,omitempty"`
}

ComputerPostSoftwareInstalledByInstallerSwuItem represents a computer post software installed by installer swu item.

func (ComputerPostSoftwareInstalledByInstallerSwuItem) MarshalXML 

func (t ComputerPostSoftwareInstalledByInstallerSwuItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostSoftwareInstalledByInstallerSwuItem root element name to the wire value declared by the spec (<installed_by_installer_swu>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostSoftwareLicensedSoftwareItem 

type ComputerPostSoftwareLicensedSoftwareItem struct {
	XMLName xml.Name
	Name    *string `xml:"name,omitempty"`
}

ComputerPostSoftwareLicensedSoftwareItem represents a computer post software licensed software item.

func (ComputerPostSoftwareLicensedSoftwareItem) MarshalXML 

func (t ComputerPostSoftwareLicensedSoftwareItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostSoftwareLicensedSoftwareItem root element name to the wire value declared by the spec (<licensed_software>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostSoftwarePlugins 

type ComputerPostSoftwarePlugins struct {
	XMLName xml.Name
	Plugin  *[]ComputerPostSoftwarePluginsPluginItem `xml:"plugin,omitempty"`
	Size    *Size                                    `xml:"size,omitempty"`
}

ComputerPostSoftwarePlugins represents a computer post software plugins.

func (ComputerPostSoftwarePlugins) MarshalXML 

func (t ComputerPostSoftwarePlugins) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostSoftwarePlugins root element name to the wire value declared by the spec (<plugins>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostSoftwarePluginsPluginItem 

type ComputerPostSoftwarePluginsPluginItem struct {
	XMLName xml.Name
	Name    *string `xml:"name,omitempty"`
	Path    *string `xml:"path,omitempty"`
	Version *string `xml:"version,omitempty"`
}

ComputerPostSoftwarePluginsPluginItem represents a computer post software plugins plugin item.

func (ComputerPostSoftwarePluginsPluginItem) MarshalXML 

func (t ComputerPostSoftwarePluginsPluginItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerPostSoftwarePluginsPluginItem root element name to the wire value declared by the spec (<plugin>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerPostSoftwareRunningServicesItem 

type ComputerPostSoftwareRunningServicesItem struct {
	Name *string `xml:"name,omitempty"`
}

ComputerPostSoftwareRunningServicesItem represents a computer post software running services item.

type ComputerReport 

type ComputerReport struct {
	XMLName   xml.Name
	Computers []ComputerReportItemComputer `xml:"Computer"`
}

ComputerReport wraps a Jamf Classic list response with a flat slice of ComputerReportItemComputer.

func (ComputerReport) MarshalXML 

func (t ComputerReport) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerReport root element name to the wire value declared by the spec (<computer_report>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerReportItem 

type ComputerReportItem struct {
	XMLName  xml.Name
	ID       *int                        `xml:"id,omitempty"`
	Computer *ComputerReportItemComputer `xml:"Computer,omitempty"`
}

ComputerReportItem represents a computer report item.

func (ComputerReportItem) MarshalXML 

func (t ComputerReportItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerReportItem root element name to the wire value declared by the spec (<computer_report>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerReportItemComputer 

type ComputerReportItemComputer struct {
	XMLName      xml.Name
	ComputerName *string `xml:"Computer_Name,omitempty"`
	ID           *int    `xml:"id,omitempty"`
}

ComputerReportItemComputer represents a computer report item computer.

func (ComputerReportItemComputer) MarshalXML 

func (t ComputerReportItemComputer) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerReportItemComputer root element name to the wire value declared by the spec (<Computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerReports 

type ComputerReports struct {
	XMLName         xml.Name
	Size            *Size                               `xml:"size,omitempty"`
	ComputerReports []ComputerReportsItemComputerReport `xml:"computer_report"`
}

ComputerReports wraps a Jamf Classic list response with a flat slice of ComputerReportsItemComputerReport.

func (ComputerReports) MarshalXML 

func (t ComputerReports) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerReports root element name to the wire value declared by the spec (<computer_reports>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerReportsItem 

type ComputerReportsItem struct {
	XMLName        xml.Name
	ID             *int                               `xml:"id,omitempty"`
	ComputerReport *ComputerReportsItemComputerReport `xml:"computer_report,omitempty"`
	Size           *Size                              `xml:"size,omitempty"`
}

ComputerReportsItem represents a computer reports item.

func (ComputerReportsItem) MarshalXML 

func (t ComputerReportsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerReportsItem root element name to the wire value declared by the spec (<computer_report>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputerReportsItemComputerReport 

type ComputerReportsItemComputerReport struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
}

ComputerReportsItemComputerReport represents a computer reports item computer report.

func (ComputerReportsItemComputerReport) MarshalXML 

func (t ComputerReportsItemComputerReport) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputerReportsItemComputerReport root element name to the wire value declared by the spec (<computer_report>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Computers 

type Computers struct {
	XMLName   xml.Name
	Size      *Size    `xml:"size,omitempty"`
	Computers []IDName `xml:"computer"`
}

Computers wraps a Jamf Classic list response with a flat slice of IDName.

func (Computers) MarshalXML 

func (t Computers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Computers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ComputersItem 

type ComputersItem struct {
	XMLName  xml.Name
	ID       *int    `xml:"id,omitempty"`
	Computer *IDName `xml:"computer,omitempty"`
	Size     *Size   `xml:"size,omitempty"`
}

ComputersItem represents a computers item.

func (ComputersItem) MarshalXML 

func (t ComputersItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ComputersItem root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Criterion 

type Criterion struct {
	XMLName xml.Name
	// Allowed values: see the CriterionAndOr constants.
	AndOr        *string `xml:"and_or,omitempty"`
	ClosingParen *bool   `xml:"closing_paren,omitempty"`
	// Name of the criteria.
	Name         *string `xml:"name,omitempty"`
	OpeningParen *bool   `xml:"opening_paren,omitempty"`
	Priority     *int    `xml:"priority,omitempty"`
	// Operator.
	SearchType *string `xml:"search_type,omitempty"`
	Value      *string `xml:"value,omitempty"`
}

Criterion represents a criterion.

func (Criterion) MarshalXML 

func (t Criterion) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Criterion root element name to the wire value declared by the spec (<criterion>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type CriterionAndOr 

type CriterionAndOr = string

CriterionAndOr is the set of values accepted by Criterion.AndOr. 

const (
	CriterionAndOrAnd CriterionAndOr = "and"
	CriterionAndOrOr  CriterionAndOr = "or"
)

CriterionAndOr 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 CriterionAndOrValues 

func CriterionAndOrValues() []CriterionAndOr

CriterionAndOrValues returns every value the Jamf API accepts for CriterionAndOr, 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 Department 

type Department struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the department.
	Name *string `xml:"name,omitempty"`
}

Department represents a department.

func (Department) MarshalXML 

func (t Department) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Department root element name to the wire value declared by the spec (<department>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Departments 

type Departments struct {
	XMLName     xml.Name
	Size        *Size        `xml:"size,omitempty"`
	Departments []Department `xml:"department"`
}

Departments wraps a Jamf Classic list response with a flat slice of Department.

func (Departments) MarshalXML 

func (t Departments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Departments root element name to the wire value declared by the spec (<departments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type DepartmentsItem 

type DepartmentsItem struct {
	XMLName    xml.Name
	ID         *int        `xml:"id,omitempty"`
	Department *Department `xml:"department,omitempty"`
	Size       *Size       `xml:"size,omitempty"`
}

DepartmentsItem represents a departments item.

func (DepartmentsItem) MarshalXML 

func (t DepartmentsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the DepartmentsItem root element name to the wire value declared by the spec (<department>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type DirectoryBinding 

type DirectoryBinding struct {
	XMLName         xml.Name
	ActiveDirectory *DirectoryBindingActiveDirectory `xml:"active_directory,omitempty"`
	Admitmac        *DirectoryBindingAdmitmac        `xml:"admitmac,omitempty"`
	Centrify        *DirectoryBindingCentrify        `xml:"centrify,omitempty"`
	// OU to bind computers to.
	ComputerOu *string `xml:"computer_ou,omitempty"`
	Domain     *string `xml:"domain,omitempty"`
	ID         *int    `xml:"id,omitempty"`
	// Name of the binding.
	Name          *string                        `xml:"name,omitempty"`
	OpenDirectory *DirectoryBindingOpenDirectory `xml:"open_directory,omitempty"`
	// Password for the network administrator account.
	Password                    *string                                      `xml:"password,omitempty"`
	PasswordSha256              *string                                      `xml:"password_sha256,omitempty"`
	PowerbrokerIdentityServices *DirectoryBindingPowerbrokerIdentityServices `xml:"powerbroker_identity_services,omitempty"`
	Priority                    *int                                         `xml:"priority,omitempty"`
	Type                        *string                                      `xml:"type,omitempty"`
	// Network administrator account to bind with.
	Username *string `xml:"username,omitempty"`
}

DirectoryBinding represents a directory binding.

func (DirectoryBinding) MarshalXML 

func (t DirectoryBinding) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the DirectoryBinding root element name to the wire value declared by the spec (<directory_binding>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type DirectoryBindingActiveDirectory 

type DirectoryBindingActiveDirectory struct {
	XMLName             xml.Name
	AdminGroups         *string `xml:"admin_groups,omitempty"`
	CacheLastUser       *bool   `xml:"cache_last_user,omitempty"`
	DefaultShell        *string `xml:"default_shell,omitempty"`
	Forest              *string `xml:"forest,omitempty"`
	Gid                 *string `xml:"gid,omitempty"`
	LocalHome           *bool   `xml:"local_home,omitempty"`
	MountStyle          *string `xml:"mount_style,omitempty"`
	MultipleDomains     *bool   `xml:"multiple_domains,omitempty"`
	PreferredDomain     *string `xml:"preferred_domain,omitempty"`
	RequireConfirmation *bool   `xml:"require_confirmation,omitempty"`
	Uid                 *string `xml:"uid,omitempty"`
	UseUncPath          *bool   `xml:"use_unc_path,omitempty"`
	UserGid             *string `xml:"user_gid,omitempty"`
}

DirectoryBindingActiveDirectory represents a directory binding active directory.

func (DirectoryBindingActiveDirectory) MarshalXML 

func (t DirectoryBindingActiveDirectory) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the DirectoryBindingActiveDirectory root element name to the wire value declared by the spec (<active_directory>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type DirectoryBindingAdmitmac 

type DirectoryBindingAdmitmac struct {
	XMLName             xml.Name
	AddUserToLocal      *bool   `xml:"add_user_to_local,omitempty"`
	AdminGroup          *string `xml:"admin_group,omitempty"`
	CachedCredentials   *int    `xml:"cached_credentials,omitempty"`
	DefaultShell        *string `xml:"default_shell,omitempty"`
	Gid                 *string `xml:"gid,omitempty"`
	GroupsOu            *string `xml:"groups_ou,omitempty"`
	LocalHome           *string `xml:"local_home,omitempty"`
	MountNetworkHome    *bool   `xml:"mount_network_home,omitempty"`
	MountStyle          *string `xml:"mount_style,omitempty"`
	PlaceHomeFolders    *string `xml:"place_home_folders,omitempty"`
	PrintersOu          *string `xml:"printers_ou,omitempty"`
	RequireConfirmation *bool   `xml:"require_confirmation,omitempty"`
	SharedFoldersOu     *string `xml:"shared_folders_ou,omitempty"`
	Uid                 *string `xml:"uid,omitempty"`
	UserGid             *string `xml:"user_gid,omitempty"`
	UsersOu             *string `xml:"users_ou,omitempty"`
}

DirectoryBindingAdmitmac represents a directory binding admitmac.

func (DirectoryBindingAdmitmac) MarshalXML 

func (t DirectoryBindingAdmitmac) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the DirectoryBindingAdmitmac root element name to the wire value declared by the spec (<admitmac>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type DirectoryBindingCentrify 

type DirectoryBindingCentrify struct {
	XMLName               xml.Name
	OverwriteExisting     *bool   `xml:"overwrite_existing,omitempty"`
	PreferredDomainServer *string `xml:"preferred_domain_server,omitempty"`
	UpdatePAM             *bool   `xml:"update_PAM,omitempty"`
	WorkstationMode       *bool   `xml:"workstation_mode,omitempty"`
	Zone                  *string `xml:"zone,omitempty"`
}

DirectoryBindingCentrify represents a directory binding centrify.

func (DirectoryBindingCentrify) MarshalXML 

func (t DirectoryBindingCentrify) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the DirectoryBindingCentrify root element name to the wire value declared by the spec (<centrify>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type DirectoryBindingOpenDirectory 

type DirectoryBindingOpenDirectory struct {
	XMLName              xml.Name
	EncryptUsingSsl      *bool `xml:"encrypt_using_ssl,omitempty"`
	PerformSecureBind    *bool `xml:"perform_secure_bind,omitempty"`
	UseForAuthentication *bool `xml:"use_for_authentication,omitempty"`
	UseForContacts       *bool `xml:"use_for_contacts,omitempty"`
}

DirectoryBindingOpenDirectory represents a directory binding open directory.

func (DirectoryBindingOpenDirectory) MarshalXML 

func (t DirectoryBindingOpenDirectory) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the DirectoryBindingOpenDirectory root element name to the wire value declared by the spec (<open_directory>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type DirectoryBindingPowerbrokerIdentityServices 

type DirectoryBindingPowerbrokerIdentityServices struct {
	XMLName xml.Name
}

DirectoryBindingPowerbrokerIdentityServices represents a directory binding powerbroker identity services.

func (DirectoryBindingPowerbrokerIdentityServices) MarshalXML 

func (t DirectoryBindingPowerbrokerIdentityServices) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the DirectoryBindingPowerbrokerIdentityServices root element name to the wire value declared by the spec (<powerbroker_identity_services>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type DirectoryBindings 

type DirectoryBindings struct {
	XMLName           xml.Name
	Size              *Size    `xml:"size,omitempty"`
	DirectoryBindings []IDName `xml:"directory_binding"`
}

DirectoryBindings wraps a Jamf Classic list response with a flat slice of IDName.

func (DirectoryBindings) MarshalXML 

func (t DirectoryBindings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the DirectoryBindings root element name to the wire value declared by the spec (<directory_bindings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type DirectoryBindingsItem 

type DirectoryBindingsItem struct {
	XMLName          xml.Name
	ID               *int    `xml:"id,omitempty"`
	DirectoryBinding *IDName `xml:"directory_binding,omitempty"`
	Size             *Size   `xml:"size,omitempty"`
}

DirectoryBindingsItem represents a directory bindings item.

func (DirectoryBindingsItem) MarshalXML 

func (t DirectoryBindingsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the DirectoryBindingsItem root element name to the wire value declared by the spec (<directory_binding>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type DiskEncryptionConfiguration 

type DiskEncryptionConfiguration struct {
	XMLName xml.Name
	// Allowed values: see the DiskEncryptionConfigurationFileVaultEnabledUsers constants.
	FileVaultEnabledUsers    *string                                              `xml:"file_vault_enabled_users,omitempty"`
	ID                       *int                                                 `xml:"id,omitempty"`
	InstitutionalRecoveryKey *DiskEncryptionConfigurationInstitutionalRecoveryKey `xml:"institutional_recovery_key,omitempty"`
	// Allowed values: see the DiskEncryptionConfigurationKeyType constants.
	KeyType *string `xml:"key_type,omitempty"`
	// Name of the disk encryption configuration.
	Name *string `xml:"name,omitempty"`
}

DiskEncryptionConfiguration represents a disk encryption configuration.

func (DiskEncryptionConfiguration) MarshalXML 

func (t DiskEncryptionConfiguration) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the DiskEncryptionConfiguration root element name to the wire value declared by the spec (<disk_encryption_configuration>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type DiskEncryptionConfigurationFileVaultEnabledUsers 

type DiskEncryptionConfigurationFileVaultEnabledUsers = string

DiskEncryptionConfigurationFileVaultEnabledUsers is the set of values accepted by DiskEncryptionConfiguration.FileVaultEnabledUsers. 

const (
	DiskEncryptionConfigurationFileVaultEnabledUsersCurrentOrNextUser DiskEncryptionConfigurationFileVaultEnabledUsers = "Current or Next User"
	DiskEncryptionConfigurationFileVaultEnabledUsersManagementAccount DiskEncryptionConfigurationFileVaultEnabledUsers = "Management Account"
)

DiskEncryptionConfigurationFileVaultEnabledUsers 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 DiskEncryptionConfigurationFileVaultEnabledUsersValues 

func DiskEncryptionConfigurationFileVaultEnabledUsersValues() []DiskEncryptionConfigurationFileVaultEnabledUsers

DiskEncryptionConfigurationFileVaultEnabledUsersValues returns every value the Jamf API accepts for DiskEncryptionConfigurationFileVaultEnabledUsers, 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 DiskEncryptionConfigurationInstitutionalRecoveryKey 

type DiskEncryptionConfigurationInstitutionalRecoveryKey struct {
	XMLName         xml.Name
	CertificateType *string `xml:"certificate_type,omitempty"`
	Data            *string `xml:"data,omitempty"`
	Key             *string `xml:"key,omitempty"`
	Password        *string `xml:"password,omitempty"`
	PasswordSha256  *string `xml:"password_sha256,omitempty"`
}

DiskEncryptionConfigurationInstitutionalRecoveryKey represents a disk encryption configuration institutional recovery key.

func (DiskEncryptionConfigurationInstitutionalRecoveryKey) MarshalXML 

func (t DiskEncryptionConfigurationInstitutionalRecoveryKey) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the DiskEncryptionConfigurationInstitutionalRecoveryKey root element name to the wire value declared by the spec (<institutional_recovery_key>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type DiskEncryptionConfigurationKeyType 

type DiskEncryptionConfigurationKeyType = string

DiskEncryptionConfigurationKeyType is the set of values accepted by DiskEncryptionConfiguration.KeyType. 

const (
	DiskEncryptionConfigurationKeyTypeIndividual                 DiskEncryptionConfigurationKeyType = "Individual"
	DiskEncryptionConfigurationKeyTypeInstitutional              DiskEncryptionConfigurationKeyType = "Institutional"
	DiskEncryptionConfigurationKeyTypeIndividualAndInstitutional DiskEncryptionConfigurationKeyType = "Individual And Institutional"
)

DiskEncryptionConfigurationKeyType 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 DiskEncryptionConfigurationKeyTypeValues 

func DiskEncryptionConfigurationKeyTypeValues() []DiskEncryptionConfigurationKeyType

DiskEncryptionConfigurationKeyTypeValues returns every value the Jamf API accepts for DiskEncryptionConfigurationKeyType, 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 DiskEncryptionConfigurations 

type DiskEncryptionConfigurations struct {
	XMLName                      xml.Name
	Size                         *Size    `xml:"size,omitempty"`
	DiskEncryptionConfigurations []IDName `xml:"disk_encryption_configuration"`
}

DiskEncryptionConfigurations wraps a Jamf Classic list response with a flat slice of IDName.

func (DiskEncryptionConfigurations) MarshalXML 

func (t DiskEncryptionConfigurations) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the DiskEncryptionConfigurations root element name to the wire value declared by the spec (<disk_encryption_configurations>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type DiskEncryptionConfigurationsItem 

type DiskEncryptionConfigurationsItem struct {
	XMLName                     xml.Name
	ID                          *int    `xml:"id,omitempty"`
	DiskEncryptionConfiguration *IDName `xml:"disk_encryption_configuration,omitempty"`
	Size                        *Size   `xml:"size,omitempty"`
}

DiskEncryptionConfigurationsItem represents a disk encryption configurations item.

func (DiskEncryptionConfigurationsItem) MarshalXML 

func (t DiskEncryptionConfigurationsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the DiskEncryptionConfigurationsItem root element name to the wire value declared by the spec (<disk_encryption_configuration>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type DistributionPoint 

type DistributionPoint struct {
	XMLName xml.Name
	// Allowed values: see the DistributionPointConnectionType constants.
	ConnectionType *string `xml:"connection_type,omitempty"`
	// Path to the share.
	Context              *string `xml:"context,omitempty"`
	EnableLoadBalancing  *bool   `xml:"enable_load_balancing,omitempty"`
	FailoverPoint        *string `xml:"failover_point,omitempty"`
	FailoverPointURL     *string `xml:"failover_point_url,omitempty"`
	HttpDownloadsEnabled *bool   `xml:"http_downloads_enabled,omitempty"`
	// Password for basic authentication.
	HttpPassword       *string `xml:"http_password,omitempty"`
	HttpPasswordSha256 *string `xml:"http_password_sha256,omitempty"`
	// URL to download packages from.
	HttpURL *string `xml:"http_url,omitempty"`
	// Username to authenticate with for basic authentication.
	HttpUsername *string `xml:"http_username,omitempty"`
	ID           *int    `xml:"id,omitempty"`
	// IP address or hostname of distribution point.
	IPAddress *string `xml:"ip_address,omitempty"`
	// Only one share can be set as master.
	IsMaster  *bool   `xml:"is_master,omitempty"`
	LocalPath *string `xml:"local_path,omitempty"`
	// Name of the distribution point.
	Name                     *string `xml:"name,omitempty"`
	NoAuthenticationRequired *bool   `xml:"no_authentication_required,omitempty"`
	Password                 *string `xml:"password,omitempty"`
	Port                     *int    `xml:"port,omitempty"`
	// Allowed values: see the DistributionPointProtocol constants.
	Protocol *string `xml:"protocol,omitempty"`
	// Password for the read only account.
	ReadOnlyPassword       *string `xml:"read_only_password,omitempty"`
	ReadOnlyPasswordSha256 *string `xml:"read_only_password_sha256,omitempty"`
	// Account with read only privileges to the share.
	ReadOnlyUsername *string `xml:"read_only_username,omitempty"`
	// Password for the read/write account.
	ReadWritePassword       *string `xml:"read_write_password,omitempty"`
	ReadWritePasswordSha256 *string `xml:"read_write_password_sha256,omitempty"`
	// Account with read/write privileges to the share.
	ReadWriteUsername *string `xml:"read_write_username,omitempty"`
	// Name of the share.
	ShareName                *string `xml:"share_name,omitempty"`
	SharePort                *int    `xml:"share_port,omitempty"`
	SshPasswordSha256        *string `xml:"ssh_password_sha256,omitempty"`
	SshUsername              *string `xml:"ssh_username,omitempty"`
	UsernamePasswordRequired *bool   `xml:"username_password_required,omitempty"`
	// Workgroup or domain of the accounts that have access to the share (SMB only).
	WorkgroupOrDomain *string `xml:"workgroup_or_domain,omitempty"`
}

DistributionPoint represents a distribution point.

func (DistributionPoint) MarshalXML 

func (t DistributionPoint) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the DistributionPoint root element name to the wire value declared by the spec (<distribution_point>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type DistributionPointConnectionType 

type DistributionPointConnectionType = string

DistributionPointConnectionType is the set of values accepted by DistributionPoint.ConnectionType. 

const (
	DistributionPointConnectionTypeSmb DistributionPointConnectionType = "SMB"
	DistributionPointConnectionTypeAfp DistributionPointConnectionType = "AFP"
)

DistributionPointConnectionType 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 DistributionPointConnectionTypeValues 

func DistributionPointConnectionTypeValues() []DistributionPointConnectionType

DistributionPointConnectionTypeValues returns every value the Jamf API accepts for DistributionPointConnectionType, 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 DistributionPointPost 

type DistributionPointPost struct {
	XMLName xml.Name
	// Allowed values: see the DistributionPointPostConnectionType constants.
	ConnectionType *string `xml:"connection_type,omitempty"`
	// Path to the share.
	Context              *string `xml:"context,omitempty"`
	EnableLoadBalancing  *bool   `xml:"enable_load_balancing,omitempty"`
	FailoverPoint        *string `xml:"failover_point,omitempty"`
	FailoverPointURL     *string `xml:"failover_point_url,omitempty"`
	HttpDownloadsEnabled *bool   `xml:"http_downloads_enabled,omitempty"`
	// Password for basic authentication.
	HttpPassword       *string `xml:"http_password,omitempty"`
	HttpPasswordSha256 *string `xml:"http_password_sha256,omitempty"`
	// URL to download packages from.
	HttpURL *string `xml:"http_url,omitempty"`
	// Username to authenticate with for basic authentication.
	HttpUsername *string `xml:"http_username,omitempty"`
	ID           *int    `xml:"id,omitempty"`
	// IP address or hostname of distribution point.
	IPAddress *string `xml:"ip_address,omitempty"`
	// Only one share can be set as master.
	IsMaster  *bool   `xml:"is_master,omitempty"`
	LocalPath *string `xml:"local_path,omitempty"`
	// Name of the distribution point.
	Name                     *string `xml:"name,omitempty"`
	NoAuthenticationRequired *bool   `xml:"no_authentication_required,omitempty"`
	Password                 *string `xml:"password,omitempty"`
	Port                     *int    `xml:"port,omitempty"`
	// Allowed values: see the DistributionPointPostProtocol constants.
	Protocol *string `xml:"protocol,omitempty"`
	// Password for the read only account.
	ReadOnlyPassword       *string `xml:"read_only_password,omitempty"`
	ReadOnlyPasswordSha256 *string `xml:"read_only_password_sha256,omitempty"`
	// Account with read only privileges to the share.
	ReadOnlyUsername *string `xml:"read_only_username,omitempty"`
	// Password for the read/write account.
	ReadWritePassword       *string `xml:"read_write_password,omitempty"`
	ReadWritePasswordSha256 *string `xml:"read_write_password_sha256,omitempty"`
	// Account with read/write privileges to the share.
	ReadWriteUsername *string `xml:"read_write_username,omitempty"`
	// Name of the share.
	ShareName                *string `xml:"share_name,omitempty"`
	SharePort                *int    `xml:"share_port,omitempty"`
	SshPasswordSha256        *string `xml:"ssh_password_sha256,omitempty"`
	SshUsername              *string `xml:"ssh_username,omitempty"`
	UsernamePasswordRequired *bool   `xml:"username_password_required,omitempty"`
	// Workgroup or domain of the accounts that have access to the share (SMB only).
	WorkgroupOrDomain *string `xml:"workgroup_or_domain,omitempty"`
}

DistributionPointPost represents a distribution point post.

func (DistributionPointPost) MarshalXML 

func (t DistributionPointPost) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the DistributionPointPost root element name to the wire value declared by the spec (<distribution_point>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type DistributionPointPostConnectionType 

type DistributionPointPostConnectionType = string

DistributionPointPostConnectionType is the set of values accepted by DistributionPointPost.ConnectionType. 

const (
	DistributionPointPostConnectionTypeSmb DistributionPointPostConnectionType = "SMB"
	DistributionPointPostConnectionTypeAfp DistributionPointPostConnectionType = "AFP"
)

DistributionPointPostConnectionType 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 DistributionPointPostConnectionTypeValues 

func DistributionPointPostConnectionTypeValues() []DistributionPointPostConnectionType

DistributionPointPostConnectionTypeValues returns every value the Jamf API accepts for DistributionPointPostConnectionType, 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 DistributionPointPostProtocol 

type DistributionPointPostProtocol = string

DistributionPointPostProtocol is the set of values accepted by DistributionPointPost.Protocol. 

const (
	DistributionPointPostProtocolHttp  DistributionPointPostProtocol = "http"
	DistributionPointPostProtocolHttps DistributionPointPostProtocol = "https"
)

DistributionPointPostProtocol 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 DistributionPointPostProtocolValues 

func DistributionPointPostProtocolValues() []DistributionPointPostProtocol

DistributionPointPostProtocolValues returns every value the Jamf API accepts for DistributionPointPostProtocol, 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 DistributionPointProtocol 

type DistributionPointProtocol = string

DistributionPointProtocol is the set of values accepted by DistributionPoint.Protocol. 

const (
	DistributionPointProtocolHttp  DistributionPointProtocol = "http"
	DistributionPointProtocolHttps DistributionPointProtocol = "https"
)

DistributionPointProtocol 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 DistributionPointProtocolValues 

func DistributionPointProtocolValues() []DistributionPointProtocol

DistributionPointProtocolValues returns every value the Jamf API accepts for DistributionPointProtocol, 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 DistributionPoints 

type DistributionPoints struct {
	XMLName            xml.Name
	Size               *Size    `xml:"size,omitempty"`
	DistributionPoints []IDName `xml:"distribution_point"`
}

DistributionPoints wraps a Jamf Classic list response with a flat slice of IDName.

func (DistributionPoints) MarshalXML 

func (t DistributionPoints) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the DistributionPoints root element name to the wire value declared by the spec (<distribution_points>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type DistributionPointsItem 

type DistributionPointsItem struct {
	XMLName           xml.Name
	ID                *int    `xml:"id,omitempty"`
	DistributionPoint *IDName `xml:"distribution_point,omitempty"`
	Size              *Size   `xml:"size,omitempty"`
}

DistributionPointsItem represents a distribution points item.

func (DistributionPointsItem) MarshalXML 

func (t DistributionPointsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the DistributionPointsItem root element name to the wire value declared by the spec (<distribution_point>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type DockItem 

type DockItem struct {
	XMLName  xml.Name
	Contents *string `xml:"contents,omitempty"`
	ID       *int    `xml:"id,omitempty"`
	// Name of the dock item.
	Name *string `xml:"name,omitempty"`
	Path *string `xml:"path,omitempty"`
	// Allowed values: see the DockItemType constants.
	Type *string `xml:"type,omitempty"`
}

DockItem represents a dock item.

func (DockItem) MarshalXML 

func (t DockItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the DockItem root element name to the wire value declared by the spec (<dock_item>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type DockItemType 

type DockItemType = string

DockItemType is the set of values accepted by DockItem.Type. 

const (
	DockItemTypeApp    DockItemType = "App"
	DockItemTypeFile   DockItemType = "File"
	DockItemTypeFolder DockItemType = "Folder"
)

DockItemType 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 DockItemTypeValues 

func DockItemTypeValues() []DockItemType

DockItemTypeValues returns every value the Jamf API accepts for DockItemType, 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 DockItems 

type DockItems struct {
	XMLName   xml.Name
	Size      *Size    `xml:"size,omitempty"`
	DockItems []IDName `xml:"dock_item"`
}

DockItems wraps a Jamf Classic list response with a flat slice of IDName.

func (DockItems) MarshalXML 

func (t DockItems) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the DockItems root element name to the wire value declared by the spec (<dock_items>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type DockItemsItem 

type DockItemsItem struct {
	XMLName  xml.Name
	ID       *int    `xml:"id,omitempty"`
	DockItem *IDName `xml:"dock_item,omitempty"`
	Size     *Size   `xml:"size,omitempty"`
}

DockItemsItem represents a dock items item.

func (DockItemsItem) MarshalXML 

func (t DockItemsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the DockItemsItem root element name to the wire value declared by the spec (<dock_item>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Ebook 

type Ebook struct {
	XMLName     xml.Name
	ID          *int              `xml:"id,omitempty"`
	General     *EbookGeneral     `xml:"general,omitempty"`
	Scope       *EbookScope       `xml:"scope,omitempty"`
	SelfService *EbookSelfService `xml:"self_service,omitempty"`
}

Ebook represents a ebook.

func (Ebook) MarshalXML 

func (t Ebook) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Ebook root element name to the wire value declared by the spec (<ebook>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookGeneral 

type EbookGeneral struct {
	XMLName         xml.Name
	Author          *string         `xml:"author,omitempty"`
	Category        *CategoryObject `xml:"category,omitempty"`
	DeployAsManaged *bool           `xml:"deploy_as_managed,omitempty"`
	// Allowed values: see the EbookGeneralDeploymentType constants.
	DeploymentType *string `xml:"deployment_type,omitempty"`
	// Allowed values: see the EbookGeneralFileType constants.
	FileType *string `xml:"file_type,omitempty"`
	Free     *bool   `xml:"free,omitempty"`
	ID       *int    `xml:"id,omitempty"`
	// Name of the ebook.
	Name            *string                      `xml:"name,omitempty"`
	SelfServiceIcon *EbookGeneralSelfServiceIcon `xml:"self_service_icon,omitempty"`
	Site            *SiteObject                  `xml:"site,omitempty"`
	// Download URL for the ebook.
	URL     *string `xml:"url,omitempty"`
	Version *string `xml:"version,omitempty"`
}

EbookGeneral represents a ebook general.

func (EbookGeneral) MarshalXML 

func (t EbookGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookGeneralDeploymentType 

type EbookGeneralDeploymentType = string

EbookGeneralDeploymentType is the set of values accepted by EbookGeneral.DeploymentType. 

const (
	EbookGeneralDeploymentTypeMakeAvailableInSelfService               EbookGeneralDeploymentType = "Make Available in Self Service"
	EbookGeneralDeploymentTypeInstallAutomaticallyPromptUsersToInstall EbookGeneralDeploymentType = "Install Automatically/Prompt Users to Install"
)

EbookGeneralDeploymentType 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 EbookGeneralDeploymentTypeValues 

func EbookGeneralDeploymentTypeValues() []EbookGeneralDeploymentType

EbookGeneralDeploymentTypeValues returns every value the Jamf API accepts for EbookGeneralDeploymentType, 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 EbookGeneralFileType 

type EbookGeneralFileType = string

EbookGeneralFileType is the set of values accepted by EbookGeneral.FileType. 

const (
	EbookGeneralFileTypePdf   EbookGeneralFileType = "PDF"
	EbookGeneralFileTypeIbook EbookGeneralFileType = "IBOOK"
	EbookGeneralFileTypeEpub  EbookGeneralFileType = "EPUB"
)

EbookGeneralFileType 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 EbookGeneralFileTypeValues 

func EbookGeneralFileTypeValues() []EbookGeneralFileType

EbookGeneralFileTypeValues returns every value the Jamf API accepts for EbookGeneralFileType, 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 EbookGeneralSelfServiceIcon 

type EbookGeneralSelfServiceIcon struct {
	XMLName xml.Name
	Data    *string `xml:"data,omitempty"`
	ID      *int    `xml:"id,omitempty"`
	URI     *string `xml:"uri,omitempty"`
}

EbookGeneralSelfServiceIcon represents a ebook general self service icon.

func (EbookGeneralSelfServiceIcon) MarshalXML 

func (t EbookGeneralSelfServiceIcon) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookGeneralSelfServiceIcon root element name to the wire value declared by the spec (<self_service_icon>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookPost 

type EbookPost struct {
	XMLName     xml.Name
	ID          *int                  `xml:"id,omitempty"`
	General     *EbookPostGeneral     `xml:"general,omitempty"`
	Scope       *EbookPostScope       `xml:"scope,omitempty"`
	SelfService *EbookPostSelfService `xml:"self_service,omitempty"`
}

EbookPost represents a ebook post.

func (EbookPost) MarshalXML 

func (t EbookPost) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookPost root element name to the wire value declared by the spec (<ebook>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookPostGeneral 

type EbookPostGeneral struct {
	XMLName         xml.Name
	Author          *string         `xml:"author,omitempty"`
	Category        *CategoryObject `xml:"category,omitempty"`
	DeployAsManaged *bool           `xml:"deploy_as_managed,omitempty"`
	// Allowed values: see the EbookPostGeneralDeploymentType constants.
	DeploymentType *string `xml:"deployment_type,omitempty"`
	// Allowed values: see the EbookPostGeneralFileType constants.
	FileType *string `xml:"file_type,omitempty"`
	Free     *bool   `xml:"free,omitempty"`
	ID       *int    `xml:"id,omitempty"`
	// Name of the ebook.
	Name            *string                      `xml:"name,omitempty"`
	SelfServiceIcon *EbookGeneralSelfServiceIcon `xml:"self_service_icon,omitempty"`
	Site            *SiteObject                  `xml:"site,omitempty"`
	// Download URL for the ebook.
	URL     *string `xml:"url,omitempty"`
	Version *string `xml:"version,omitempty"`
}

EbookPostGeneral represents a ebook post general.

func (EbookPostGeneral) MarshalXML 

func (t EbookPostGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookPostGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookPostGeneralDeploymentType 

type EbookPostGeneralDeploymentType = string

EbookPostGeneralDeploymentType is the set of values accepted by EbookPostGeneral.DeploymentType. 

const (
	EbookPostGeneralDeploymentTypeMakeAvailableInSelfService               EbookPostGeneralDeploymentType = "Make Available in Self Service"
	EbookPostGeneralDeploymentTypeInstallAutomaticallyPromptUsersToInstall EbookPostGeneralDeploymentType = "Install Automatically/Prompt Users to Install"
)

EbookPostGeneralDeploymentType 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 EbookPostGeneralDeploymentTypeValues 

func EbookPostGeneralDeploymentTypeValues() []EbookPostGeneralDeploymentType

EbookPostGeneralDeploymentTypeValues returns every value the Jamf API accepts for EbookPostGeneralDeploymentType, 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 EbookPostGeneralFileType 

type EbookPostGeneralFileType = string

EbookPostGeneralFileType is the set of values accepted by EbookPostGeneral.FileType. 

const (
	EbookPostGeneralFileTypePdf   EbookPostGeneralFileType = "PDF"
	EbookPostGeneralFileTypeIbook EbookPostGeneralFileType = "IBOOK"
	EbookPostGeneralFileTypeEpub  EbookPostGeneralFileType = "EPUB"
)

EbookPostGeneralFileType 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 EbookPostGeneralFileTypeValues 

func EbookPostGeneralFileTypeValues() []EbookPostGeneralFileType

EbookPostGeneralFileTypeValues returns every value the Jamf API accepts for EbookPostGeneralFileType, 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 EbookPostScope 

type EbookPostScope struct {
	XMLName            xml.Name
	ID                 *int                          `xml:"id,omitempty"`
	AllComputers       *bool                         `xml:"all_computers,omitempty"`
	AllJssUsers        *bool                         `xml:"all_jss_users,omitempty"`
	AllMobileDevices   *bool                         `xml:"all_mobile_devices,omitempty"`
	Buildings          *EbookScopeBuildings          `xml:"buildings,omitempty"`
	Classes            *EbookScopeClasses            `xml:"classes,omitempty"`
	ComputerGroups     *EbookScopeComputerGroups     `xml:"computer_groups,omitempty"`
	Computers          *EbookScopeComputers          `xml:"computers,omitempty"`
	Departments        *EbookScopeDepartments        `xml:"departments,omitempty"`
	Exclusions         *EbookScopeExclusions         `xml:"exclusions,omitempty"`
	JssUserGroups      *EbookScopeJssUserGroups      `xml:"jss_user_groups,omitempty"`
	JssUsers           *EbookScopeJssUsers           `xml:"jss_users,omitempty"`
	Limitations        *EbookScopeLimitations        `xml:"limitations,omitempty"`
	MobileDeviceGroups *EbookScopeMobileDeviceGroups `xml:"mobile_device_groups,omitempty"`
	MobileDevices      *EbookScopeMobileDevices      `xml:"mobile_devices,omitempty"`
}

EbookPostScope represents a ebook post scope.

func (EbookPostScope) MarshalXML 

func (t EbookPostScope) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookPostScope root element name to the wire value declared by the spec (<scope>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookPostSelfService 

type EbookPostSelfService struct {
	XMLName                     xml.Name
	ID                          *int                                   `xml:"id,omitempty"`
	FeatureOnMainPage           *bool                                  `xml:"feature_on_main_page,omitempty"`
	ForceUsersToViewDescription *bool                                  `xml:"force_users_to_view_description,omitempty"`
	InstallButtonText           *string                                `xml:"install_button_text,omitempty"`
	Notification                *NotificationValue                     `xml:"notification"`
	NotificationMessage         *string                                `xml:"notification_message,omitempty"`
	NotificationSubject         *string                                `xml:"notification_subject,omitempty"`
	SelfServiceCategories       *EbookSelfServiceSelfServiceCategories `xml:"self_service_categories,omitempty"`
	SelfServiceDescription      *string                                `xml:"self_service_description,omitempty"`
	SelfServiceDisplayName      *string                                `xml:"self_service_display_name,omitempty"`
	SelfServiceIcon             *EbookSelfServiceSelfServiceIcon       `xml:"self_service_icon,omitempty"`
}

EbookPostSelfService represents a ebook post self service.

func (EbookPostSelfService) MarshalXML 

func (t EbookPostSelfService) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookPostSelfService root element name to the wire value declared by the spec (<self_service>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScope 

type EbookScope struct {
	XMLName            xml.Name
	ID                 *int                          `xml:"id,omitempty"`
	AllComputers       *bool                         `xml:"all_computers,omitempty"`
	AllJssUsers        *bool                         `xml:"all_jss_users,omitempty"`
	AllMobileDevices   *bool                         `xml:"all_mobile_devices,omitempty"`
	Buildings          *EbookScopeBuildings          `xml:"buildings,omitempty"`
	Classes            *EbookScopeClasses            `xml:"classes,omitempty"`
	ComputerGroups     *EbookScopeComputerGroups     `xml:"computer_groups,omitempty"`
	Computers          *EbookScopeComputers          `xml:"computers,omitempty"`
	Departments        *EbookScopeDepartments        `xml:"departments,omitempty"`
	Exclusions         *EbookScopeExclusions         `xml:"exclusions,omitempty"`
	JssUserGroups      *EbookScopeJssUserGroups      `xml:"jss_user_groups,omitempty"`
	JssUsers           *EbookScopeJssUsers           `xml:"jss_users,omitempty"`
	Limitations        *EbookScopeLimitations        `xml:"limitations,omitempty"`
	MobileDeviceGroups *EbookScopeMobileDeviceGroups `xml:"mobile_device_groups,omitempty"`
	MobileDevices      *EbookScopeMobileDevices      `xml:"mobile_devices,omitempty"`
}

EbookScope represents a ebook scope.

func (EbookScope) MarshalXML 

func (t EbookScope) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScope root element name to the wire value declared by the spec (<scope>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeBuildings 

type EbookScopeBuildings struct {
	XMLName  xml.Name
	Building *[]IDName `xml:"building,omitempty"`
}

EbookScopeBuildings represents a ebook scope buildings.

func (EbookScopeBuildings) MarshalXML 

func (t EbookScopeBuildings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeBuildings root element name to the wire value declared by the spec (<buildings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeClasses 

type EbookScopeClasses struct {
	XMLName xml.Name
	Class   *[]IDName `xml:"class,omitempty"`
}

EbookScopeClasses represents a ebook scope classes.

func (EbookScopeClasses) MarshalXML 

func (t EbookScopeClasses) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeClasses root element name to the wire value declared by the spec (<classes>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeComputerGroups 

type EbookScopeComputerGroups struct {
	XMLName       xml.Name
	ComputerGroup *[]IDName `xml:"computer_group,omitempty"`
}

EbookScopeComputerGroups represents a ebook scope computer groups.

func (EbookScopeComputerGroups) MarshalXML 

func (t EbookScopeComputerGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeComputerGroups root element name to the wire value declared by the spec (<computer_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeComputers 

type EbookScopeComputers struct {
	XMLName  xml.Name
	Computer *[]EbookScopeComputersComputerItem `xml:"computer,omitempty"`
}

EbookScopeComputers represents a ebook scope computers.

func (EbookScopeComputers) MarshalXML 

func (t EbookScopeComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeComputersComputerItem 

type EbookScopeComputersComputerItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the computer.
	Name *string `xml:"name,omitempty"`
	UDID *string `xml:"udid,omitempty"`
}

EbookScopeComputersComputerItem represents a ebook scope computers computer item.

func (EbookScopeComputersComputerItem) MarshalXML 

func (t EbookScopeComputersComputerItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeComputersComputerItem root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeDepartments 

type EbookScopeDepartments struct {
	XMLName    xml.Name
	Department *[]IDName `xml:"department,omitempty"`
}

EbookScopeDepartments represents a ebook scope departments.

func (EbookScopeDepartments) MarshalXML 

func (t EbookScopeDepartments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeDepartments root element name to the wire value declared by the spec (<departments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeExclusions 

type EbookScopeExclusions struct {
	XMLName            xml.Name
	ID                 *int                                    `xml:"id,omitempty"`
	Buildings          *EbookScopeExclusionsBuildings          `xml:"buildings,omitempty"`
	ComputerGroups     *EbookScopeExclusionsComputerGroups     `xml:"computer_groups,omitempty"`
	Computers          *EbookScopeExclusionsComputers          `xml:"computers,omitempty"`
	Departments        *EbookScopeExclusionsDepartments        `xml:"departments,omitempty"`
	JssUserGroups      *EbookScopeExclusionsJssUserGroups      `xml:"jss_user_groups,omitempty"`
	JssUsers           *EbookScopeExclusionsJssUsers           `xml:"jss_users,omitempty"`
	MobileDeviceGroups *EbookScopeExclusionsMobileDeviceGroups `xml:"mobile_device_groups,omitempty"`
	MobileDevices      *EbookScopeExclusionsMobileDevices      `xml:"mobile_devices,omitempty"`
	NetworkSegments    *EbookScopeExclusionsNetworkSegments    `xml:"network_segments,omitempty"`
	UserGroups         *EbookScopeExclusionsUserGroups         `xml:"user_groups,omitempty"`
	Users              *EbookScopeExclusionsUsers              `xml:"users,omitempty"`
}

EbookScopeExclusions represents a ebook scope exclusions.

func (EbookScopeExclusions) MarshalXML 

func (t EbookScopeExclusions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeExclusions root element name to the wire value declared by the spec (<exclusions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeExclusionsBuildings 

type EbookScopeExclusionsBuildings struct {
	XMLName  xml.Name
	Building *[]IDName `xml:"building,omitempty"`
}

EbookScopeExclusionsBuildings represents a ebook scope exclusions buildings.

func (EbookScopeExclusionsBuildings) MarshalXML 

func (t EbookScopeExclusionsBuildings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeExclusionsBuildings root element name to the wire value declared by the spec (<buildings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeExclusionsComputerGroups 

type EbookScopeExclusionsComputerGroups struct {
	XMLName       xml.Name
	ComputerGroup *[]IDName `xml:"computer_group,omitempty"`
}

EbookScopeExclusionsComputerGroups represents a ebook scope exclusions computer groups.

func (EbookScopeExclusionsComputerGroups) MarshalXML 

func (t EbookScopeExclusionsComputerGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeExclusionsComputerGroups root element name to the wire value declared by the spec (<computer_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeExclusionsComputers 

type EbookScopeExclusionsComputers struct {
	XMLName  xml.Name
	Computer *[]EbookScopeExclusionsComputersComputerItem `xml:"computer,omitempty"`
}

EbookScopeExclusionsComputers represents a ebook scope exclusions computers.

func (EbookScopeExclusionsComputers) MarshalXML 

func (t EbookScopeExclusionsComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeExclusionsComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeExclusionsComputersComputerItem 

type EbookScopeExclusionsComputersComputerItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the computer.
	Name *string `xml:"name,omitempty"`
	UDID *string `xml:"udid,omitempty"`
}

EbookScopeExclusionsComputersComputerItem represents a ebook scope exclusions computers computer item.

func (EbookScopeExclusionsComputersComputerItem) MarshalXML 

func (t EbookScopeExclusionsComputersComputerItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeExclusionsComputersComputerItem root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeExclusionsDepartments 

type EbookScopeExclusionsDepartments struct {
	XMLName    xml.Name
	Department *[]IDName `xml:"department,omitempty"`
}

EbookScopeExclusionsDepartments represents a ebook scope exclusions departments.

func (EbookScopeExclusionsDepartments) MarshalXML 

func (t EbookScopeExclusionsDepartments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeExclusionsDepartments root element name to the wire value declared by the spec (<departments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeExclusionsJssUserGroups 

type EbookScopeExclusionsJssUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

EbookScopeExclusionsJssUserGroups represents a ebook scope exclusions jss user groups.

func (EbookScopeExclusionsJssUserGroups) MarshalXML 

func (t EbookScopeExclusionsJssUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeExclusionsJssUserGroups root element name to the wire value declared by the spec (<jss_user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeExclusionsJssUsers 

type EbookScopeExclusionsJssUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

EbookScopeExclusionsJssUsers represents a ebook scope exclusions jss users.

func (EbookScopeExclusionsJssUsers) MarshalXML 

func (t EbookScopeExclusionsJssUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeExclusionsJssUsers root element name to the wire value declared by the spec (<jss_users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeExclusionsMobileDeviceGroups 

type EbookScopeExclusionsMobileDeviceGroups struct {
	XMLName           xml.Name
	MobileDeviceGroup *[]IDName `xml:"mobile_device_group,omitempty"`
}

EbookScopeExclusionsMobileDeviceGroups represents a ebook scope exclusions mobile device groups.

func (EbookScopeExclusionsMobileDeviceGroups) MarshalXML 

func (t EbookScopeExclusionsMobileDeviceGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeExclusionsMobileDeviceGroups root element name to the wire value declared by the spec (<mobile_device_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeExclusionsMobileDevices 

type EbookScopeExclusionsMobileDevices struct {
	XMLName      xml.Name
	MobileDevice *[]EbookScopeExclusionsMobileDevicesMobileDeviceItem `xml:"mobile_device,omitempty"`
}

EbookScopeExclusionsMobileDevices represents a ebook scope exclusions mobile devices.

func (EbookScopeExclusionsMobileDevices) MarshalXML 

func (t EbookScopeExclusionsMobileDevices) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeExclusionsMobileDevices root element name to the wire value declared by the spec (<mobile_devices>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeExclusionsMobileDevicesMobileDeviceItem 

type EbookScopeExclusionsMobileDevicesMobileDeviceItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the device.
	Name           *string `xml:"name,omitempty"`
	UDID           *string `xml:"udid,omitempty"`
	WifiMacAddress *string `xml:"wifi_mac_address,omitempty"`
}

EbookScopeExclusionsMobileDevicesMobileDeviceItem represents a ebook scope exclusions mobile devices mobile device item.

func (EbookScopeExclusionsMobileDevicesMobileDeviceItem) MarshalXML 

func (t EbookScopeExclusionsMobileDevicesMobileDeviceItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeExclusionsMobileDevicesMobileDeviceItem root element name to the wire value declared by the spec (<mobile_device>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeExclusionsNetworkSegments 

type EbookScopeExclusionsNetworkSegments struct {
	XMLName        xml.Name
	NetworkSegment *[]EbookScopeExclusionsNetworkSegmentsNetworkSegmentItem `xml:"network_segment,omitempty"`
}

EbookScopeExclusionsNetworkSegments represents a ebook scope exclusions network segments.

func (EbookScopeExclusionsNetworkSegments) MarshalXML 

func (t EbookScopeExclusionsNetworkSegments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeExclusionsNetworkSegments root element name to the wire value declared by the spec (<network_segments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeExclusionsNetworkSegmentsNetworkSegmentItem 

type EbookScopeExclusionsNetworkSegmentsNetworkSegmentItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the network segment.
	Name *string `xml:"name,omitempty"`
	Uid  *string `xml:"uid,omitempty"`
}

EbookScopeExclusionsNetworkSegmentsNetworkSegmentItem represents a ebook scope exclusions network segments network segment item.

func (EbookScopeExclusionsNetworkSegmentsNetworkSegmentItem) MarshalXML 

func (t EbookScopeExclusionsNetworkSegmentsNetworkSegmentItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeExclusionsNetworkSegmentsNetworkSegmentItem root element name to the wire value declared by the spec (<network_segment>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeExclusionsUserGroups 

type EbookScopeExclusionsUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

EbookScopeExclusionsUserGroups represents a ebook scope exclusions user groups.

func (EbookScopeExclusionsUserGroups) MarshalXML 

func (t EbookScopeExclusionsUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeExclusionsUserGroups root element name to the wire value declared by the spec (<user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeExclusionsUsers 

type EbookScopeExclusionsUsers struct {
	XMLName xml.Name
	User    *[]EbookScopeExclusionsUsersUserItem `xml:"user,omitempty"`
}

EbookScopeExclusionsUsers represents a ebook scope exclusions users.

func (EbookScopeExclusionsUsers) MarshalXML 

func (t EbookScopeExclusionsUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeExclusionsUsers root element name to the wire value declared by the spec (<users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeExclusionsUsersUserItem 

type EbookScopeExclusionsUsersUserItem struct {
	XMLName xml.Name
	Name    *string `xml:"name,omitempty"`
}

EbookScopeExclusionsUsersUserItem represents a ebook scope exclusions users user item.

func (EbookScopeExclusionsUsersUserItem) MarshalXML 

func (t EbookScopeExclusionsUsersUserItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeExclusionsUsersUserItem root element name to the wire value declared by the spec (<user>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeJssUserGroups 

type EbookScopeJssUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

EbookScopeJssUserGroups represents a ebook scope jss user groups.

func (EbookScopeJssUserGroups) MarshalXML 

func (t EbookScopeJssUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeJssUserGroups root element name to the wire value declared by the spec (<jss_user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeJssUsers 

type EbookScopeJssUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

EbookScopeJssUsers represents a ebook scope jss users.

func (EbookScopeJssUsers) MarshalXML 

func (t EbookScopeJssUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeJssUsers root element name to the wire value declared by the spec (<jss_users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeLimitations 

type EbookScopeLimitations struct {
	XMLName         xml.Name
	ID              *int                                  `xml:"id,omitempty"`
	NetworkSegments *EbookScopeLimitationsNetworkSegments `xml:"network_segments,omitempty"`
	UserGroups      *EbookScopeLimitationsUserGroups      `xml:"user_groups,omitempty"`
	Users           *EbookScopeLimitationsUsers           `xml:"users,omitempty"`
}

EbookScopeLimitations represents a ebook scope limitations.

func (EbookScopeLimitations) MarshalXML 

func (t EbookScopeLimitations) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeLimitations root element name to the wire value declared by the spec (<limitations>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeLimitationsNetworkSegments 

type EbookScopeLimitationsNetworkSegments struct {
	XMLName        xml.Name
	NetworkSegment *[]IDName `xml:"network_segment,omitempty"`
}

EbookScopeLimitationsNetworkSegments represents a ebook scope limitations network segments.

func (EbookScopeLimitationsNetworkSegments) MarshalXML 

func (t EbookScopeLimitationsNetworkSegments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeLimitationsNetworkSegments root element name to the wire value declared by the spec (<network_segments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeLimitationsUserGroups 

type EbookScopeLimitationsUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

EbookScopeLimitationsUserGroups represents a ebook scope limitations user groups.

func (EbookScopeLimitationsUserGroups) MarshalXML 

func (t EbookScopeLimitationsUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeLimitationsUserGroups root element name to the wire value declared by the spec (<user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeLimitationsUsers 

type EbookScopeLimitationsUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

EbookScopeLimitationsUsers represents a ebook scope limitations users.

func (EbookScopeLimitationsUsers) MarshalXML 

func (t EbookScopeLimitationsUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeLimitationsUsers root element name to the wire value declared by the spec (<users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeMobileDeviceGroups 

type EbookScopeMobileDeviceGroups struct {
	XMLName           xml.Name
	MobileDeviceGroup *[]IDName `xml:"mobile_device_group,omitempty"`
}

EbookScopeMobileDeviceGroups represents a ebook scope mobile device groups.

func (EbookScopeMobileDeviceGroups) MarshalXML 

func (t EbookScopeMobileDeviceGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeMobileDeviceGroups root element name to the wire value declared by the spec (<mobile_device_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeMobileDevices 

type EbookScopeMobileDevices struct {
	XMLName      xml.Name
	MobileDevice *[]EbookScopeMobileDevicesMobileDeviceItem `xml:"mobile_device,omitempty"`
}

EbookScopeMobileDevices represents a ebook scope mobile devices.

func (EbookScopeMobileDevices) MarshalXML 

func (t EbookScopeMobileDevices) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeMobileDevices root element name to the wire value declared by the spec (<mobile_devices>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookScopeMobileDevicesMobileDeviceItem 

type EbookScopeMobileDevicesMobileDeviceItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the device.
	Name           *string `xml:"name,omitempty"`
	UDID           *string `xml:"udid,omitempty"`
	WifiMacAddress *string `xml:"wifi_mac_address,omitempty"`
}

EbookScopeMobileDevicesMobileDeviceItem represents a ebook scope mobile devices mobile device item.

func (EbookScopeMobileDevicesMobileDeviceItem) MarshalXML 

func (t EbookScopeMobileDevicesMobileDeviceItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookScopeMobileDevicesMobileDeviceItem root element name to the wire value declared by the spec (<mobile_device>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookSelfService 

type EbookSelfService struct {
	XMLName                     xml.Name
	ID                          *int                                   `xml:"id,omitempty"`
	FeatureOnMainPage           *bool                                  `xml:"feature_on_main_page,omitempty"`
	ForceUsersToViewDescription *bool                                  `xml:"force_users_to_view_description,omitempty"`
	InstallButtonText           *string                                `xml:"install_button_text,omitempty"`
	Notification                *NotificationValue                     `xml:"notification"`
	NotificationMessage         *string                                `xml:"notification_message,omitempty"`
	NotificationSubject         *string                                `xml:"notification_subject,omitempty"`
	SelfServiceCategories       *EbookSelfServiceSelfServiceCategories `xml:"self_service_categories,omitempty"`
	SelfServiceDescription      *string                                `xml:"self_service_description,omitempty"`
	SelfServiceDisplayName      *string                                `xml:"self_service_display_name,omitempty"`
	SelfServiceIcon             *EbookSelfServiceSelfServiceIcon       `xml:"self_service_icon,omitempty"`
}

EbookSelfService represents a ebook self service.

func (EbookSelfService) MarshalXML 

func (t EbookSelfService) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookSelfService root element name to the wire value declared by the spec (<self_service>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookSelfServiceSelfServiceCategories 

type EbookSelfServiceSelfServiceCategories struct {
	XMLName  xml.Name
	Category *[]EbookSelfServiceSelfServiceCategoriesCategoryItem `xml:"category,omitempty"`
}

EbookSelfServiceSelfServiceCategories represents a ebook self service self service categories.

func (EbookSelfServiceSelfServiceCategories) MarshalXML 

func (t EbookSelfServiceSelfServiceCategories) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookSelfServiceSelfServiceCategories root element name to the wire value declared by the spec (<self_service_categories>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookSelfServiceSelfServiceCategoriesCategoryItem 

type EbookSelfServiceSelfServiceCategoriesCategoryItem struct {
	XMLName   xml.Name
	DisplayIn *bool   `xml:"display_in,omitempty"`
	FeatureIn *bool   `xml:"feature_in,omitempty"`
	ID        *int    `xml:"id,omitempty"`
	Name      *string `xml:"name,omitempty"`
}

EbookSelfServiceSelfServiceCategoriesCategoryItem represents a ebook self service self service categories category item.

func (EbookSelfServiceSelfServiceCategoriesCategoryItem) MarshalXML 

func (t EbookSelfServiceSelfServiceCategoriesCategoryItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookSelfServiceSelfServiceCategoriesCategoryItem root element name to the wire value declared by the spec (<category>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbookSelfServiceSelfServiceIcon 

type EbookSelfServiceSelfServiceIcon struct {
	XMLName xml.Name
	Data    *string `xml:"data,omitempty"`
	ID      *int    `xml:"id,omitempty"`
	URI     *string `xml:"uri,omitempty"`
}

EbookSelfServiceSelfServiceIcon represents a ebook self service self service icon.

func (EbookSelfServiceSelfServiceIcon) MarshalXML 

func (t EbookSelfServiceSelfServiceIcon) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbookSelfServiceSelfServiceIcon root element name to the wire value declared by the spec (<self_service_icon>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Ebooks 

type Ebooks struct {
	XMLName xml.Name
	Size    *Size    `xml:"size,omitempty"`
	Ebooks  []IDName `xml:"ebook"`
}

Ebooks wraps a Jamf Classic list response with a flat slice of IDName.

func (Ebooks) MarshalXML 

func (t Ebooks) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Ebooks root element name to the wire value declared by the spec (<ebooks>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type EbooksItem 

type EbooksItem struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Ebook   *IDName `xml:"ebook,omitempty"`
	Size    *Size   `xml:"size,omitempty"`
}

EbooksItem represents a ebooks item.

func (EbooksItem) MarshalXML 

func (t EbooksItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the EbooksItem root element name to the wire value declared by the spec (<ebook>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Group 

type Group struct {
	XMLName xml.Name
	// Allowed values: see the GroupAccessLevel constants.
	AccessLevel *string          `xml:"access_level,omitempty"`
	ID          *int             `xml:"id,omitempty"`
	LdapServer  *GroupLdapServer `xml:"ldap_server,omitempty"`
	Members     *GroupMembers    `xml:"members,omitempty"`
	// Group name.
	Name *string `xml:"name,omitempty"`
	// Allowed values: see the GroupPrivilegeSet constants.
	PrivilegeSet *string          `xml:"privilege_set,omitempty"`
	Privileges   *GroupPrivileges `xml:"privileges,omitempty"`
	Site         *Site            `xml:"site,omitempty"`
}

Group represents a group.

func (Group) MarshalXML 

func (t Group) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Group root element name to the wire value declared by the spec (<group>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type GroupAccessLevel 

type GroupAccessLevel = string

GroupAccessLevel is the set of values accepted by Group.AccessLevel. 

const (
	GroupAccessLevelFullAccess  GroupAccessLevel = "Full Access"
	GroupAccessLevelSiteAccess  GroupAccessLevel = "Site Access"
	GroupAccessLevelGroupAccess GroupAccessLevel = "Group Access"
)

GroupAccessLevel 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 GroupAccessLevelValues 

func GroupAccessLevelValues() []GroupAccessLevel

GroupAccessLevelValues returns every value the Jamf API accepts for GroupAccessLevel, 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 GroupLdapServer 

type GroupLdapServer struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
}

GroupLdapServer represents a group ldap server.

func (GroupLdapServer) MarshalXML 

func (t GroupLdapServer) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the GroupLdapServer root element name to the wire value declared by the spec (<ldap_server>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type GroupMembers 

type GroupMembers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

GroupMembers represents a group members.

func (GroupMembers) MarshalXML 

func (t GroupMembers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the GroupMembers root element name to the wire value declared by the spec (<members>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type GroupPrivilegeSet 

type GroupPrivilegeSet = string

GroupPrivilegeSet is the set of values accepted by Group.PrivilegeSet. 

const (
	GroupPrivilegeSetAdministrator  GroupPrivilegeSet = "Administrator"
	GroupPrivilegeSetAuditor        GroupPrivilegeSet = "Auditor"
	GroupPrivilegeSetEnrollmentOnly GroupPrivilegeSet = "Enrollment Only"
	GroupPrivilegeSetCustom         GroupPrivilegeSet = "Custom"
)

GroupPrivilegeSet 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 GroupPrivilegeSetValues 

func GroupPrivilegeSetValues() []GroupPrivilegeSet

GroupPrivilegeSetValues returns every value the Jamf API accepts for GroupPrivilegeSet, 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 GroupPrivileges 

type GroupPrivileges struct {
	XMLName       xml.Name
	ID            *int                          `xml:"id,omitempty"`
	CasperAdmin   *GroupPrivilegesCasperAdmin   `xml:"casper_admin,omitempty"`
	CasperImaging *GroupPrivilegesCasperImaging `xml:"casper_imaging,omitempty"`
	CasperRemote  *GroupPrivilegesCasperRemote  `xml:"casper_remote,omitempty"`
	JssActions    *GroupPrivilegesJssActions    `xml:"jss_actions,omitempty"`
	JssObjects    *GroupPrivilegesJssObjects    `xml:"jss_objects,omitempty"`
	JssSettings   *GroupPrivilegesJssSettings   `xml:"jss_settings,omitempty"`
	Recon         *GroupPrivilegesRecon         `xml:"recon,omitempty"`
}

GroupPrivileges represents a group privileges.

func (GroupPrivileges) MarshalXML 

func (t GroupPrivileges) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the GroupPrivileges root element name to the wire value declared by the spec (<privileges>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type GroupPrivilegesCasperAdmin 

type GroupPrivilegesCasperAdmin struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

GroupPrivilegesCasperAdmin represents a group privileges casper admin.

func (GroupPrivilegesCasperAdmin) MarshalXML 

func (t GroupPrivilegesCasperAdmin) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the GroupPrivilegesCasperAdmin root element name to the wire value declared by the spec (<casper_admin>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type GroupPrivilegesCasperImaging 

type GroupPrivilegesCasperImaging struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

GroupPrivilegesCasperImaging represents a group privileges casper imaging.

func (GroupPrivilegesCasperImaging) MarshalXML 

func (t GroupPrivilegesCasperImaging) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the GroupPrivilegesCasperImaging root element name to the wire value declared by the spec (<casper_imaging>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type GroupPrivilegesCasperRemote 

type GroupPrivilegesCasperRemote struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

GroupPrivilegesCasperRemote represents a group privileges casper remote.

func (GroupPrivilegesCasperRemote) MarshalXML 

func (t GroupPrivilegesCasperRemote) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the GroupPrivilegesCasperRemote root element name to the wire value declared by the spec (<casper_remote>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type GroupPrivilegesJssActions 

type GroupPrivilegesJssActions struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

GroupPrivilegesJssActions represents a group privileges jss actions.

func (GroupPrivilegesJssActions) MarshalXML 

func (t GroupPrivilegesJssActions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the GroupPrivilegesJssActions root element name to the wire value declared by the spec (<jss_actions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type GroupPrivilegesJssObjects 

type GroupPrivilegesJssObjects struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

GroupPrivilegesJssObjects represents a group privileges jss objects.

func (GroupPrivilegesJssObjects) MarshalXML 

func (t GroupPrivilegesJssObjects) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the GroupPrivilegesJssObjects root element name to the wire value declared by the spec (<jss_objects>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type GroupPrivilegesJssSettings 

type GroupPrivilegesJssSettings struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

GroupPrivilegesJssSettings represents a group privileges jss settings.

func (GroupPrivilegesJssSettings) MarshalXML 

func (t GroupPrivilegesJssSettings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the GroupPrivilegesJssSettings root element name to the wire value declared by the spec (<jss_settings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type GroupPrivilegesRecon 

type GroupPrivilegesRecon struct {
	XMLName   xml.Name
	Privilege *[]string `xml:"privilege,omitempty"`
}

GroupPrivilegesRecon represents a group privileges recon.

func (GroupPrivilegesRecon) MarshalXML 

func (t GroupPrivilegesRecon) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the GroupPrivilegesRecon root element name to the wire value declared by the spec (<recon>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type GsxConnection 

type GsxConnection struct {
	XMLName       xml.Name
	AccountNumber *int  `xml:"account_number,omitempty"`
	Enabled       *bool `xml:"enabled,omitempty"`
	// Allowed values: see the GsxConnectionRegion constants.
	Region   *string `xml:"region,omitempty"`
	URI      *string `xml:"uri,omitempty"`
	Username *string `xml:"username,omitempty"`
}

GsxConnection represents a gsx connection.

func (GsxConnection) MarshalXML 

func (t GsxConnection) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the GsxConnection root element name to the wire value declared by the spec (<gsx_connection>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type GsxConnectionRegion 

type GsxConnectionRegion = string

GsxConnectionRegion is the set of values accepted by GsxConnection.Region. 

const (
	GsxConnectionRegionAmericas     GsxConnectionRegion = "Americas"
	GsxConnectionRegionApac         GsxConnectionRegion = "APAC"
	GsxConnectionRegionEmea         GsxConnectionRegion = "EMEA"
	GsxConnectionRegionLatinAmerica GsxConnectionRegion = "LatinAmerica"
)

GsxConnectionRegion 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 GsxConnectionRegionValues 

func GsxConnectionRegionValues() []GsxConnectionRegion

GsxConnectionRegionValues returns every value the Jamf API accepts for GsxConnectionRegion, 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 HealthcareListener 

type HealthcareListener = []HealthcareListenerItem

HealthcareListener is a list of HealthcareListenerItem.

type HealthcareListenerItem 

type HealthcareListenerItem struct {
	XMLName                xml.Name
	Enabled                *bool                        `xml:"enabled,omitempty"`
	ID                     *int                         `xml:"id,omitempty"`
	InfratructureManagerID *int                         `xml:"infratructure_manager_id,omitempty"`
	Name                   *string                      `xml:"name,omitempty"`
	Port                   *int                         `xml:"port,omitempty"`
	RangeIps               *string                      `xml:"range_ips,omitempty"`
	Rules                  *HealthcareListenerItemRules `xml:"rules,omitempty"`
	SingleIps              *string                      `xml:"single_ips,omitempty"`
}

HealthcareListenerItem represents a healthcare listener item.

func (HealthcareListenerItem) MarshalXML 

func (t HealthcareListenerItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the HealthcareListenerItem root element name to the wire value declared by the spec (<healthcare_listener>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type HealthcareListenerItemRules 

type HealthcareListenerItemRules struct {
	XMLName xml.Name
	Rule    *[]HealthcareListenerItemRulesRuleItem `xml:"rule,omitempty"`
}

HealthcareListenerItemRules represents a healthcare listener item rules.

func (HealthcareListenerItemRules) MarshalXML 

func (t HealthcareListenerItemRules) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the HealthcareListenerItemRules root element name to the wire value declared by the spec (<rules>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type HealthcareListenerItemRulesRuleItem 

type HealthcareListenerItemRulesRuleItem struct {
	XMLName                  xml.Name
	AdtMessage               *string                                                      `xml:"adt_message,omitempty"`
	AdtMessageField          *string                                                      `xml:"adt_message_field,omitempty"`
	DeviceInventoryField     *int                                                         `xml:"device_inventory_field,omitempty"`
	HclID                    *int                                                         `xml:"hcl_id,omitempty"`
	ID                       *int                                                         `xml:"id,omitempty"`
	MDMCommand               *string                                                      `xml:"mdm_command,omitempty"`
	MDMCommandAdditionalData *HealthcareListenerItemRulesRuleItemMDMCommandAdditionalData `xml:"mdm_command_additional_data,omitempty"`
	Name                     *string                                                      `xml:"name,omitempty"`
	NotificationEmails       *HealthcareListenerItemRulesRuleItemNotificationEmails       `xml:"notification_emails,omitempty"`
	NotificationEnabled      *bool                                                        `xml:"notification_enabled,omitempty"`
	NotificationThreshold    *int                                                         `xml:"notification_threshold,omitempty"`
	NotifyUnsupportedEnabled *bool                                                        `xml:"notify_unsupported_enabled,omitempty"`
	OperatingSystem          *string                                                      `xml:"operating_system,omitempty"`
}

HealthcareListenerItemRulesRuleItem represents a healthcare listener item rules rule item.

func (HealthcareListenerItemRulesRuleItem) MarshalXML 

func (t HealthcareListenerItemRulesRuleItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the HealthcareListenerItemRulesRuleItem root element name to the wire value declared by the spec (<rule>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type HealthcareListenerItemRulesRuleItemMDMCommandAdditionalData 

type HealthcareListenerItemRulesRuleItemMDMCommandAdditionalData struct {
	XMLName            xml.Name
	LostModeFootnote   *string `xml:"lost_mode_footnote,omitempty"`
	LostModeMessage    *string `xml:"lost_mode_message,omitempty"`
	LostModeOption     *string `xml:"lost_mode_option,omitempty"`
	LostModePersistent *string `xml:"lost_mode_persistent,omitempty"`
	LostModePhone      *string `xml:"lost_mode_phone,omitempty"`
	LostModeSound      *bool   `xml:"lost_mode_sound,omitempty"`
}

HealthcareListenerItemRulesRuleItemMDMCommandAdditionalData represents a healthcare listener item rules rule item m d m command additional data.

func (HealthcareListenerItemRulesRuleItemMDMCommandAdditionalData) MarshalXML 

func (t HealthcareListenerItemRulesRuleItemMDMCommandAdditionalData) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the HealthcareListenerItemRulesRuleItemMDMCommandAdditionalData root element name to the wire value declared by the spec (<mdm_command_additional_data>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type HealthcareListenerItemRulesRuleItemNotificationEmails 

type HealthcareListenerItemRulesRuleItemNotificationEmails struct {
	XMLName xml.Name
	Email   *string `xml:"email,omitempty"`
}

HealthcareListenerItemRulesRuleItemNotificationEmails represents a healthcare listener item rules rule item notification emails.

func (HealthcareListenerItemRulesRuleItemNotificationEmails) MarshalXML 

func (t HealthcareListenerItemRulesRuleItemNotificationEmails) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the HealthcareListenerItemRulesRuleItemNotificationEmails root element name to the wire value declared by the spec (<notification_emails>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type HealthcareListenerRule 

type HealthcareListenerRule struct {
	XMLName         xml.Name
	AdtMessage      *string `xml:"adt_message,omitempty"`
	AdtMessageField *string `xml:"adt_message_field,omitempty"`
	// -1 represents the location field 'Room'; any other number is a mobile device extension attribute ID.
	DeviceInventoryField *int `xml:"device_inventory_field,omitempty"`
	HclID                *int `xml:"hcl_id,omitempty"`
	ID                   *int `xml:"id,omitempty"`
	// Allowed values: see the HealthcareListenerRuleMDMCommand constants.
	MDMCommand               *string                                   `xml:"mdm_command,omitempty"`
	MDMCommandAdditionalData *string                                   `xml:"mdm_command_additional_data,omitempty"`
	Name                     *string                                   `xml:"name,omitempty"`
	NotificationEmails       *HealthcareListenerRuleNotificationEmails `xml:"notification_emails,omitempty"`
	NotificationEnabled      *bool                                     `xml:"notification_enabled,omitempty"`
	NotificationThreshold    *int                                      `xml:"notification_threshold,omitempty"`
	NotifyUnsupportedEnabled *bool                                     `xml:"notify_unsupported_enabled,omitempty"`
	// Allowed values: see the HealthcareListenerRuleOperatingSystem constants.
	OperatingSystem *string `xml:"operating_system,omitempty"`
}

HealthcareListenerRule represents a healthcare listener rule.

func (HealthcareListenerRule) MarshalXML 

func (t HealthcareListenerRule) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the HealthcareListenerRule root element name to the wire value declared by the spec (<healthcare_listener_rule>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type HealthcareListenerRuleMDMCommand 

type HealthcareListenerRuleMDMCommand = string

HealthcareListenerRuleMDMCommand is the set of values accepted by HealthcareListenerRule.MDMCommand. 

const (
	HealthcareListenerRuleMDMCommandEraseDevice    HealthcareListenerRuleMDMCommand = "EraseDevice"
	HealthcareListenerRuleMDMCommandDeviceLock     HealthcareListenerRuleMDMCommand = "DeviceLock"
	HealthcareListenerRuleMDMCommandEnableLostMode HealthcareListenerRuleMDMCommand = "EnableLostMode"
)

HealthcareListenerRuleMDMCommand 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 HealthcareListenerRuleMDMCommandValues 

func HealthcareListenerRuleMDMCommandValues() []HealthcareListenerRuleMDMCommand

HealthcareListenerRuleMDMCommandValues returns every value the Jamf API accepts for HealthcareListenerRuleMDMCommand, 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 HealthcareListenerRuleNotificationEmails 

type HealthcareListenerRuleNotificationEmails struct {
	XMLName xml.Name
	Email   *string `xml:"email,omitempty"`
}

HealthcareListenerRuleNotificationEmails represents a healthcare listener rule notification emails.

func (HealthcareListenerRuleNotificationEmails) MarshalXML 

func (t HealthcareListenerRuleNotificationEmails) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the HealthcareListenerRuleNotificationEmails root element name to the wire value declared by the spec (<notification_emails>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type HealthcareListenerRuleOperatingSystem 

type HealthcareListenerRuleOperatingSystem = string

HealthcareListenerRuleOperatingSystem is the set of values accepted by HealthcareListenerRule.OperatingSystem. 

const (
	HealthcareListenerRuleOperatingSystemIPhone HealthcareListenerRuleOperatingSystem = "iPhone"
	HealthcareListenerRuleOperatingSystemTv     HealthcareListenerRuleOperatingSystem = "TV"
)

HealthcareListenerRuleOperatingSystem 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 HealthcareListenerRuleOperatingSystemValues 

func HealthcareListenerRuleOperatingSystemValues() []HealthcareListenerRuleOperatingSystem

HealthcareListenerRuleOperatingSystemValues returns every value the Jamf API accepts for HealthcareListenerRuleOperatingSystem, 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 HealthcareListenerRules 

type HealthcareListenerRules struct {
	XMLName                 xml.Name
	Size                    *Size                    `xml:"size,omitempty"`
	HealthcareListenerRules []HealthcareListenerRule `xml:"healthcare_listener_rule"`
}

HealthcareListenerRules wraps a Jamf Classic list response with a flat slice of HealthcareListenerRule.

func (HealthcareListenerRules) MarshalXML 

func (t HealthcareListenerRules) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the HealthcareListenerRules root element name to the wire value declared by the spec (<healthcare_listener_rules>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type HealthcareListenerRulesItem 

type HealthcareListenerRulesItem struct {
	XMLName                xml.Name
	ID                     *int                    `xml:"id,omitempty"`
	HealthcareListenerRule *HealthcareListenerRule `xml:"healthcare_listener_rule,omitempty"`
	Size                   *Size                   `xml:"size,omitempty"`
}

HealthcareListenerRulesItem represents a healthcare listener rules item.

func (HealthcareListenerRulesItem) MarshalXML 

func (t HealthcareListenerRulesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the HealthcareListenerRulesItem root element name to the wire value declared by the spec (<healthcare_listener_rule>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type HealthcareListeners 

type HealthcareListeners struct {
	XMLName             xml.Name
	Size                *Size                `xml:"size,omitempty"`
	HealthcareListeners []HealthcareListener `xml:"healthcare_listener"`
}

HealthcareListeners wraps a Jamf Classic list response with a flat slice of HealthcareListener.

func (HealthcareListeners) MarshalXML 

func (t HealthcareListeners) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the HealthcareListeners root element name to the wire value declared by the spec (<healthcare_listeners>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type HealthcareListenersItem 

type HealthcareListenersItem struct {
	XMLName            xml.Name
	ID                 *int                `xml:"id,omitempty"`
	HealthcareListener *HealthcareListener `xml:"healthcare_listener,omitempty"`
	Size               *Size               `xml:"size,omitempty"`
}

HealthcareListenersItem represents a healthcare listeners item.

func (HealthcareListenersItem) MarshalXML 

func (t HealthcareListenersItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the HealthcareListenersItem root element name to the wire value declared by the spec (<healthcare_listener>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type IDName 

type IDName struct {
	ID   *int    `xml:"id,omitempty"`
	Name *string `xml:"name,omitempty"`
}

IDName represents a i d name.

type Ibeacon 

type Ibeacon struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Major   *string `xml:"major,omitempty"`
	Minor   *string `xml:"minor,omitempty"`
	// Name of the ibeacon.
	Name *string `xml:"name,omitempty"`
	UUID *string `xml:"uuid,omitempty"`
}

Ibeacon represents a ibeacon.

func (Ibeacon) MarshalXML 

func (t Ibeacon) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Ibeacon root element name to the wire value declared by the spec (<ibeacon>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Ibeacons 

type Ibeacons struct {
	XMLName  xml.Name
	Size     *Size     `xml:"size,omitempty"`
	Ibeacons []Ibeacon `xml:"ibeacon"`
}

Ibeacons wraps a Jamf Classic list response with a flat slice of Ibeacon.

func (Ibeacons) MarshalXML 

func (t Ibeacons) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Ibeacons root element name to the wire value declared by the spec (<ibeacons>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type IbeaconsItem 

type IbeaconsItem struct {
	XMLName xml.Name
	ID      *int     `xml:"id,omitempty"`
	Ibeacon *Ibeacon `xml:"ibeacon,omitempty"`
	Size    *Size    `xml:"size,omitempty"`
}

IbeaconsItem represents a ibeacons item.

func (IbeaconsItem) MarshalXML 

func (t IbeaconsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the IbeaconsItem root element name to the wire value declared by the spec (<ibeacon>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type InfrastructureManager 

type InfrastructureManager struct {
	XMLName                   xml.Name
	Hostname                  *string `xml:"hostname,omitempty"`
	ID                        *int    `xml:"id,omitempty"`
	LastCheckIn               *string `xml:"last_check_in,omitempty"`
	LastReportedIp            *string `xml:"last_reported_ip,omitempty"`
	Name                      *string `xml:"name,omitempty"`
	OperatingSystem           *string `xml:"operating_system,omitempty"`
	OperatingSystemVersion    *string `xml:"operating_system_version,omitempty"`
	RecurringCheckInFrequency *int    `xml:"recurring_check_in_frequency,omitempty"`
	UUID                      *string `xml:"uuid,omitempty"`
}

InfrastructureManager represents a infrastructure manager.

func (InfrastructureManager) MarshalXML 

func (t InfrastructureManager) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the InfrastructureManager root element name to the wire value declared by the spec (<infrastructure_manager>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type InfrastructureManagers 

type InfrastructureManagers struct {
	XMLName                xml.Name
	Size                   *Size                   `xml:"size,omitempty"`
	InfrastructureManagers []InfrastructureManager `xml:"infrastructure_manager"`
}

InfrastructureManagers wraps a Jamf Classic list response with a flat slice of InfrastructureManager.

func (InfrastructureManagers) MarshalXML 

func (t InfrastructureManagers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the InfrastructureManagers root element name to the wire value declared by the spec (<infrastructure_managers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type InfrastructureManagersItem 

type InfrastructureManagersItem struct {
	XMLName               xml.Name
	ID                    *int                   `xml:"id,omitempty"`
	InfrastructureManager *InfrastructureManager `xml:"infrastructure_manager,omitempty"`
	Size                  *Size                  `xml:"size,omitempty"`
}

InfrastructureManagersItem represents a infrastructure managers item.

func (InfrastructureManagersItem) MarshalXML 

func (t InfrastructureManagersItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the InfrastructureManagersItem root element name to the wire value declared by the spec (<infrastructure_manager>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type JsonWebTokenConfiguration 

type JsonWebTokenConfiguration struct {
	XMLName  xml.Name
	Disabled *bool `xml:"disabled,omitempty"`
	// Write-only. Servers MUST NOT return this field in responses; the SDK preserves it only so the caller
	// can supply a value on update.
	EncryptionKey *string `xml:"encryption_key,omitempty"`
	ID            *int    `xml:"id,omitempty"`
	Name          *string `xml:"name,omitempty"`
	TokenExpiry   *int    `xml:"token_expiry,omitempty"`
}

JsonWebTokenConfiguration represents a json web token configuration.

func (JsonWebTokenConfiguration) MarshalXML 

func (t JsonWebTokenConfiguration) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the JsonWebTokenConfiguration root element name to the wire value declared by the spec (<json_web_token_configuration>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type JsonWebTokenConfigurations 

type JsonWebTokenConfigurations struct {
	XMLName                    xml.Name
	JsonWebTokenConfigurations []JsonWebTokenConfiguration `xml:"json_web_token_configuration"`
}

JsonWebTokenConfigurations wraps a Jamf Classic list response with a flat slice of JsonWebTokenConfiguration.

func (JsonWebTokenConfigurations) MarshalXML 

func (t JsonWebTokenConfigurations) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the JsonWebTokenConfigurations root element name to the wire value declared by the spec (<json_web_token_configurations>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type JsonWebTokenConfigurationsItem 

type JsonWebTokenConfigurationsItem struct {
	XMLName                   xml.Name
	ID                        *int                       `xml:"id,omitempty"`
	JsonWebTokenConfiguration *JsonWebTokenConfiguration `xml:"json_web_token_configuration,omitempty"`
}

JsonWebTokenConfigurationsItem represents a json web token configurations item.

func (JsonWebTokenConfigurationsItem) MarshalXML 

func (t JsonWebTokenConfigurationsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the JsonWebTokenConfigurationsItem root element name to the wire value declared by the spec (<json_web_token_configuration>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type JssUser 

type JssUser struct {
	XMLName     xml.Name
	Institution *string                  `xml:"institution,omitempty"`
	LicenseType *string                  `xml:"license_type,omitempty"`
	Privileges  *[]JssUserPrivilegesItem `xml:"privileges,omitempty"`
	Product     *string                  `xml:"product,omitempty"`
	Version     *string                  `xml:"version,omitempty"`
}

JssUser represents a jss user.

func (JssUser) MarshalXML 

func (t JssUser) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the JssUser root element name to the wire value declared by the spec (<user>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type JssUserPrivilegesItem 

type JssUserPrivilegesItem struct {
	Privilege *string `xml:"privilege,omitempty"`
}

JssUserPrivilegesItem represents a jss user privileges item.

type LdapServer 

type LdapServer struct {
	XMLName          xml.Name
	ID               *int                        `xml:"id,omitempty"`
	Connection       *LdapServerConnection       `xml:"connection,omitempty"`
	MappingsForUsers *LdapServerMappingsForUsers `xml:"mappings_for_users,omitempty"`
}

LdapServer represents a ldap server.

func (LdapServer) MarshalXML 

func (t LdapServer) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LdapServer root element name to the wire value declared by the spec (<ldap_server>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LdapServerConnection 

type LdapServerConnection struct {
	XMLName xml.Name
	Account *LdapServerConnectionAccount `xml:"account,omitempty"`
	// Allowed values: see the LdapServerConnectionAuthenticationType constants.
	AuthenticationType *string `xml:"authentication_type,omitempty"`
	CertificatesUsed   *string `xml:"certificates_used,omitempty"`
	// Hostname or IP address of the server.
	Hostname     *string `xml:"hostname,omitempty"`
	ID           *int    `xml:"id,omitempty"`
	IsEnabled    *bool   `xml:"is_enabled,omitempty"`
	MigratedToID *int    `xml:"migrated_to_id,omitempty"`
	// Name of the LDAP server.
	Name *string `xml:"name,omitempty"`
	// Timeout in seconds.
	OpenCloseTimeout *int `xml:"open_close_timeout,omitempty"`
	Port             *int `xml:"port,omitempty"`
	// Allowed values: see the LdapServerConnectionReferralResponse constants.
	ReferralResponse *string `xml:"referral_response,omitempty"`
	// Timeout in seconds.
	SearchTimeout *int `xml:"search_timeout,omitempty"`
	// Allowed values: see the LdapServerConnectionServerType constants.
	ServerType   *string `xml:"server_type,omitempty"`
	UseSsl       *bool   `xml:"use_ssl,omitempty"`
	UseWildcards *bool   `xml:"use_wildcards,omitempty"`
}

LdapServerConnection represents a ldap server connection.

func (LdapServerConnection) MarshalXML 

func (t LdapServerConnection) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LdapServerConnection root element name to the wire value declared by the spec (<connection>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LdapServerConnectionAccount 

type LdapServerConnectionAccount struct {
	XMLName               xml.Name
	DistinguishedUsername *string `xml:"distinguished_username,omitempty"`
	Password              *string `xml:"password,omitempty"`
	PasswordSha256        *string `xml:"password_sha256,omitempty"`
}

LdapServerConnectionAccount represents a ldap server connection account.

func (LdapServerConnectionAccount) MarshalXML 

func (t LdapServerConnectionAccount) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LdapServerConnectionAccount root element name to the wire value declared by the spec (<account>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LdapServerConnectionAuthenticationType 

type LdapServerConnectionAuthenticationType = string

LdapServerConnectionAuthenticationType is the set of values accepted by LdapServerConnection.AuthenticationType. 

const (
	LdapServerConnectionAuthenticationTypeSimple    LdapServerConnectionAuthenticationType = "simple"
	LdapServerConnectionAuthenticationTypeCramMd5   LdapServerConnectionAuthenticationType = "CRAM-MD5"
	LdapServerConnectionAuthenticationTypeDigestMd5 LdapServerConnectionAuthenticationType = "DIGEST-MD5"
	LdapServerConnectionAuthenticationTypeNone      LdapServerConnectionAuthenticationType = "none"
)

LdapServerConnectionAuthenticationType 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 LdapServerConnectionAuthenticationTypeValues 

func LdapServerConnectionAuthenticationTypeValues() []LdapServerConnectionAuthenticationType

LdapServerConnectionAuthenticationTypeValues returns every value the Jamf API accepts for LdapServerConnectionAuthenticationType, 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 LdapServerConnectionReferralResponse 

type LdapServerConnectionReferralResponse = string

LdapServerConnectionReferralResponse is the set of values accepted by LdapServerConnection.ReferralResponse. 

const (
	LdapServerConnectionReferralResponseIgnore LdapServerConnectionReferralResponse = "ignore"
	LdapServerConnectionReferralResponseFollow LdapServerConnectionReferralResponse = "follow"
)

LdapServerConnectionReferralResponse 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 LdapServerConnectionReferralResponseValues 

func LdapServerConnectionReferralResponseValues() []LdapServerConnectionReferralResponse

LdapServerConnectionReferralResponseValues returns every value the Jamf API accepts for LdapServerConnectionReferralResponse, 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 LdapServerConnectionServerType 

type LdapServerConnectionServerType = string

LdapServerConnectionServerType is the set of values accepted by LdapServerConnection.ServerType. 

const (
	LdapServerConnectionServerTypeActiveDirectory LdapServerConnectionServerType = "Active Directory"
	LdapServerConnectionServerTypeOpenDirectory   LdapServerConnectionServerType = "Open Directory"
	LdapServerConnectionServerTypeEDirectory      LdapServerConnectionServerType = "eDirectory"
	LdapServerConnectionServerTypeCustom          LdapServerConnectionServerType = "Custom"
)

LdapServerConnectionServerType 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 LdapServerConnectionServerTypeValues 

func LdapServerConnectionServerTypeValues() []LdapServerConnectionServerType

LdapServerConnectionServerTypeValues returns every value the Jamf API accepts for LdapServerConnectionServerType, 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 LdapServerMappingsForUsers 

type LdapServerMappingsForUsers struct {
	XMLName                     xml.Name
	ID                          *int                                                   `xml:"id,omitempty"`
	UserGroupMappings           *LdapServerMappingsForUsersUserGroupMappings           `xml:"user_group_mappings,omitempty"`
	UserGroupMembershipMappings *LdapServerMappingsForUsersUserGroupMembershipMappings `xml:"user_group_membership_mappings,omitempty"`
	UserMappings                *LdapServerMappingsForUsersUserMappings                `xml:"user_mappings,omitempty"`
}

LdapServerMappingsForUsers represents a ldap server mappings for users.

func (LdapServerMappingsForUsers) MarshalXML 

func (t LdapServerMappingsForUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LdapServerMappingsForUsers root element name to the wire value declared by the spec (<mappings_for_users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LdapServerMappingsForUsersUserGroupMappings 

type LdapServerMappingsForUsersUserGroupMappings struct {
	XMLName      xml.Name
	MapGroupID   *string `xml:"map_group_id,omitempty"`
	MapGroupName *string `xml:"map_group_name,omitempty"`
	MapGroupUUID *string `xml:"map_group_uuid,omitempty"`
	// Allowed values: see the LdapServerMappingsForUsersUserGroupMappingsMapObjectClassToAnyOrAll
	// constants.
	MapObjectClassToAnyOrAll *string `xml:"map_object_class_to_any_or_all,omitempty"`
	ObjectClasses            *string `xml:"object_classes,omitempty"`
	SearchBase               *string `xml:"search_base,omitempty"`
	// Allowed values: see the LdapServerMappingsForUsersUserGroupMappingsSearchScope constants.
	SearchScope *string `xml:"search_scope,omitempty"`
}

LdapServerMappingsForUsersUserGroupMappings represents a ldap server mappings for users user group mappings.

func (LdapServerMappingsForUsersUserGroupMappings) MarshalXML 

func (t LdapServerMappingsForUsersUserGroupMappings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LdapServerMappingsForUsersUserGroupMappings root element name to the wire value declared by the spec (<user_group_mappings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LdapServerMappingsForUsersUserGroupMappingsMapObjectClassToAnyOrAll 

type LdapServerMappingsForUsersUserGroupMappingsMapObjectClassToAnyOrAll = string

LdapServerMappingsForUsersUserGroupMappingsMapObjectClassToAnyOrAll is the set of values accepted by LdapServerMappingsForUsersUserGroupMappings.MapObjectClassToAnyOrAll. 

const (
	LdapServerMappingsForUsersUserGroupMappingsMapObjectClassToAnyOrAllAll LdapServerMappingsForUsersUserGroupMappingsMapObjectClassToAnyOrAll = "all"
	LdapServerMappingsForUsersUserGroupMappingsMapObjectClassToAnyOrAllAny LdapServerMappingsForUsersUserGroupMappingsMapObjectClassToAnyOrAll = "any"
)

LdapServerMappingsForUsersUserGroupMappingsMapObjectClassToAnyOrAll 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 LdapServerMappingsForUsersUserGroupMappingsMapObjectClassToAnyOrAllValues 

func LdapServerMappingsForUsersUserGroupMappingsMapObjectClassToAnyOrAllValues() []LdapServerMappingsForUsersUserGroupMappingsMapObjectClassToAnyOrAll

LdapServerMappingsForUsersUserGroupMappingsMapObjectClassToAnyOrAllValues returns every value the Jamf API accepts for LdapServerMappingsForUsersUserGroupMappingsMapObjectClassToAnyOrAll, 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 LdapServerMappingsForUsersUserGroupMappingsSearchScope 

type LdapServerMappingsForUsersUserGroupMappingsSearchScope = string

LdapServerMappingsForUsersUserGroupMappingsSearchScope is the set of values accepted by LdapServerMappingsForUsersUserGroupMappings.SearchScope. 

const (
	LdapServerMappingsForUsersUserGroupMappingsSearchScopeAllSubtrees    LdapServerMappingsForUsersUserGroupMappingsSearchScope = "All Subtrees"
	LdapServerMappingsForUsersUserGroupMappingsSearchScopeFirstLevelOnly LdapServerMappingsForUsersUserGroupMappingsSearchScope = "First Level Only"
)

LdapServerMappingsForUsersUserGroupMappingsSearchScope 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 LdapServerMappingsForUsersUserGroupMappingsSearchScopeValues 

func LdapServerMappingsForUsersUserGroupMappingsSearchScopeValues() []LdapServerMappingsForUsersUserGroupMappingsSearchScope

LdapServerMappingsForUsersUserGroupMappingsSearchScopeValues returns every value the Jamf API accepts for LdapServerMappingsForUsersUserGroupMappingsSearchScope, 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 LdapServerMappingsForUsersUserGroupMembershipMappings 

type LdapServerMappingsForUsersUserGroupMembershipMappings struct {
	XMLName                                          xml.Name
	AppendToUsername                                 *string `xml:"append_to_username,omitempty"`
	GroupID                                          *string `xml:"group_id,omitempty"`
	GroupMembershipEnabledWhenUserMembershipSelected *bool   `xml:"group_membership_enabled_when_user_membership_selected,omitempty"`
	MapGroupMembershipToUserField                    *string `xml:"map_group_membership_to_user_field,omitempty"`
	// Allowed values: see the
	// LdapServerMappingsForUsersUserGroupMembershipMappingsMapObjectClassToAnyOrAll constants.
	MapObjectClassToAnyOrAll      *string `xml:"map_object_class_to_any_or_all,omitempty"`
	MapUserMembershipToGroupField *string `xml:"map_user_membership_to_group_field"`
	MapUserMembershipUseDn        *bool   `xml:"map_user_membership_use_dn,omitempty"`
	MembershipScopingOptimization *bool   `xml:"membership_scoping_optimization,omitempty"`
	ObjectClasses                 *string `xml:"object_classes,omitempty"`
	RecursiveLookups              *bool   `xml:"recursive_lookups,omitempty"`
	SearchBase                    *string `xml:"search_base,omitempty"`
	// Allowed values: see the LdapServerMappingsForUsersUserGroupMembershipMappingsSearchScope constants.
	SearchScope *string `xml:"search_scope,omitempty"`
	UseDn       *bool   `xml:"use_dn,omitempty"`
	// Allowed values: see the
	// LdapServerMappingsForUsersUserGroupMembershipMappingsUserGroupMembershipStoredIn constants.
	UserGroupMembershipStoredIn       *string `xml:"user_group_membership_stored_in,omitempty"`
	UserGroupMembershipUseLdapCompare *bool   `xml:"user_group_membership_use_ldap_compare,omitempty"`
	Username                          *string `xml:"username,omitempty"`
}

LdapServerMappingsForUsersUserGroupMembershipMappings represents a ldap server mappings for users user group membership mappings.

func (LdapServerMappingsForUsersUserGroupMembershipMappings) MarshalXML 

func (t LdapServerMappingsForUsersUserGroupMembershipMappings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LdapServerMappingsForUsersUserGroupMembershipMappings root element name to the wire value declared by the spec (<user_group_membership_mappings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LdapServerMappingsForUsersUserGroupMembershipMappingsMapObjectClassToAnyOrAll 

type LdapServerMappingsForUsersUserGroupMembershipMappingsMapObjectClassToAnyOrAll = string

LdapServerMappingsForUsersUserGroupMembershipMappingsMapObjectClassToAnyOrAll is the set of values accepted by LdapServerMappingsForUsersUserGroupMembershipMappings.MapObjectClassToAnyOrAll. 

const (
	LdapServerMappingsForUsersUserGroupMembershipMappingsMapObjectClassToAnyOrAllAll LdapServerMappingsForUsersUserGroupMembershipMappingsMapObjectClassToAnyOrAll = "all"
	LdapServerMappingsForUsersUserGroupMembershipMappingsMapObjectClassToAnyOrAllAny LdapServerMappingsForUsersUserGroupMembershipMappingsMapObjectClassToAnyOrAll = "any"
)

LdapServerMappingsForUsersUserGroupMembershipMappingsMapObjectClassToAnyOrAll 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 LdapServerMappingsForUsersUserGroupMembershipMappingsMapObjectClassToAnyOrAllValues 

func LdapServerMappingsForUsersUserGroupMembershipMappingsMapObjectClassToAnyOrAllValues() []LdapServerMappingsForUsersUserGroupMembershipMappingsMapObjectClassToAnyOrAll

LdapServerMappingsForUsersUserGroupMembershipMappingsMapObjectClassToAnyOrAllValues returns every value the Jamf API accepts for LdapServerMappingsForUsersUserGroupMembershipMappingsMapObjectClassToAnyOrAll, 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 LdapServerMappingsForUsersUserGroupMembershipMappingsSearchScope 

type LdapServerMappingsForUsersUserGroupMembershipMappingsSearchScope = string

LdapServerMappingsForUsersUserGroupMembershipMappingsSearchScope is the set of values accepted by LdapServerMappingsForUsersUserGroupMembershipMappings.SearchScope. 

const (
	LdapServerMappingsForUsersUserGroupMembershipMappingsSearchScopeAllSubtrees    LdapServerMappingsForUsersUserGroupMembershipMappingsSearchScope = "All Subtrees"
	LdapServerMappingsForUsersUserGroupMembershipMappingsSearchScopeFirstLevelOnly LdapServerMappingsForUsersUserGroupMembershipMappingsSearchScope = "First Level Only"
)

LdapServerMappingsForUsersUserGroupMembershipMappingsSearchScope 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 LdapServerMappingsForUsersUserGroupMembershipMappingsSearchScopeValues 

func LdapServerMappingsForUsersUserGroupMembershipMappingsSearchScopeValues() []LdapServerMappingsForUsersUserGroupMembershipMappingsSearchScope

LdapServerMappingsForUsersUserGroupMembershipMappingsSearchScopeValues returns every value the Jamf API accepts for LdapServerMappingsForUsersUserGroupMembershipMappingsSearchScope, 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 LdapServerMappingsForUsersUserGroupMembershipMappingsUserGroupMembershipStoredIn 

type LdapServerMappingsForUsersUserGroupMembershipMappingsUserGroupMembershipStoredIn = string

LdapServerMappingsForUsersUserGroupMembershipMappingsUserGroupMembershipStoredIn is the set of values accepted by LdapServerMappingsForUsersUserGroupMembershipMappings.UserGroupMembershipStoredIn. 

const (
	LdapServerMappingsForUsersUserGroupMembershipMappingsUserGroupMembershipStoredInUserObject  LdapServerMappingsForUsersUserGroupMembershipMappingsUserGroupMembershipStoredIn = "user object"
	LdapServerMappingsForUsersUserGroupMembershipMappingsUserGroupMembershipStoredInGroupObject LdapServerMappingsForUsersUserGroupMembershipMappingsUserGroupMembershipStoredIn = "group object"
)

LdapServerMappingsForUsersUserGroupMembershipMappingsUserGroupMembershipStoredIn 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 LdapServerMappingsForUsersUserGroupMembershipMappingsUserGroupMembershipStoredInValues 

func LdapServerMappingsForUsersUserGroupMembershipMappingsUserGroupMembershipStoredInValues() []LdapServerMappingsForUsersUserGroupMembershipMappingsUserGroupMembershipStoredIn

LdapServerMappingsForUsersUserGroupMembershipMappingsUserGroupMembershipStoredInValues returns every value the Jamf API accepts for LdapServerMappingsForUsersUserGroupMembershipMappingsUserGroupMembershipStoredIn, 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 LdapServerMappingsForUsersUserMappings 

type LdapServerMappingsForUsersUserMappings struct {
	XMLName              xml.Name
	AppendToEmailResults *string `xml:"append_to_email_results,omitempty"`
	MapBuilding          *string `xml:"map_building,omitempty"`
	MapDepartment        *string `xml:"map_department,omitempty"`
	MapEmailAddress      *string `xml:"map_email_address,omitempty"`
	// Allowed values: see the LdapServerMappingsForUsersUserMappingsMapObjectClassToAnyOrAll constants.
	MapObjectClassToAnyOrAll *string `xml:"map_object_class_to_any_or_all,omitempty"`
	MapPhone                 *string `xml:"map_phone,omitempty"`
	MapPosition              *string `xml:"map_position,omitempty"`
	MapRealname              *string `xml:"map_realname,omitempty"`
	MapRoom                  *string `xml:"map_room,omitempty"`
	MapUserID                *string `xml:"map_user_id,omitempty"`
	MapUserUUID              *string `xml:"map_user_uuid,omitempty"`
	MapUsername              *string `xml:"map_username,omitempty"`
	ObjectClasses            *string `xml:"object_classes,omitempty"`
	SearchBase               *string `xml:"search_base,omitempty"`
	// Allowed values: see the LdapServerMappingsForUsersUserMappingsSearchScope constants.
	SearchScope *string `xml:"search_scope,omitempty"`
}

LdapServerMappingsForUsersUserMappings represents a ldap server mappings for users user mappings.

func (LdapServerMappingsForUsersUserMappings) MarshalXML 

func (t LdapServerMappingsForUsersUserMappings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LdapServerMappingsForUsersUserMappings root element name to the wire value declared by the spec (<user_mappings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LdapServerMappingsForUsersUserMappingsMapObjectClassToAnyOrAll 

type LdapServerMappingsForUsersUserMappingsMapObjectClassToAnyOrAll = string

LdapServerMappingsForUsersUserMappingsMapObjectClassToAnyOrAll is the set of values accepted by LdapServerMappingsForUsersUserMappings.MapObjectClassToAnyOrAll. 

const (
	LdapServerMappingsForUsersUserMappingsMapObjectClassToAnyOrAllAll LdapServerMappingsForUsersUserMappingsMapObjectClassToAnyOrAll = "all"
	LdapServerMappingsForUsersUserMappingsMapObjectClassToAnyOrAllAny LdapServerMappingsForUsersUserMappingsMapObjectClassToAnyOrAll = "any"
)

LdapServerMappingsForUsersUserMappingsMapObjectClassToAnyOrAll 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 LdapServerMappingsForUsersUserMappingsMapObjectClassToAnyOrAllValues 

func LdapServerMappingsForUsersUserMappingsMapObjectClassToAnyOrAllValues() []LdapServerMappingsForUsersUserMappingsMapObjectClassToAnyOrAll

LdapServerMappingsForUsersUserMappingsMapObjectClassToAnyOrAllValues returns every value the Jamf API accepts for LdapServerMappingsForUsersUserMappingsMapObjectClassToAnyOrAll, 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 LdapServerMappingsForUsersUserMappingsSearchScope 

type LdapServerMappingsForUsersUserMappingsSearchScope = string

LdapServerMappingsForUsersUserMappingsSearchScope is the set of values accepted by LdapServerMappingsForUsersUserMappings.SearchScope. 

const (
	LdapServerMappingsForUsersUserMappingsSearchScopeAllSubtrees    LdapServerMappingsForUsersUserMappingsSearchScope = "All Subtrees"
	LdapServerMappingsForUsersUserMappingsSearchScopeFirstLevelOnly LdapServerMappingsForUsersUserMappingsSearchScope = "First Level Only"
)

LdapServerMappingsForUsersUserMappingsSearchScope 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 LdapServerMappingsForUsersUserMappingsSearchScopeValues 

func LdapServerMappingsForUsersUserMappingsSearchScopeValues() []LdapServerMappingsForUsersUserMappingsSearchScope

LdapServerMappingsForUsersUserMappingsSearchScopeValues returns every value the Jamf API accepts for LdapServerMappingsForUsersUserMappingsSearchScope, 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 LdapServerPost 

type LdapServerPost struct {
	XMLName          xml.Name
	ID               *int                            `xml:"id,omitempty"`
	Connection       *LdapServerPostConnection       `xml:"connection,omitempty"`
	MappingsForUsers *LdapServerPostMappingsForUsers `xml:"mappings_for_users,omitempty"`
}

LdapServerPost represents a ldap server post.

func (LdapServerPost) MarshalXML 

func (t LdapServerPost) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LdapServerPost root element name to the wire value declared by the spec (<ldap_server>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LdapServerPostConnection 

type LdapServerPostConnection struct {
	XMLName xml.Name
	Account *LdapServerConnectionAccount `xml:"account,omitempty"`
	// Allowed values: see the LdapServerPostConnectionAuthenticationType constants.
	AuthenticationType *string `xml:"authentication_type,omitempty"`
	CertificatesUsed   *string `xml:"certificates_used,omitempty"`
	// Hostname or IP address of the server.
	Hostname     *string `xml:"hostname,omitempty"`
	ID           *int    `xml:"id,omitempty"`
	IsEnabled    *bool   `xml:"is_enabled,omitempty"`
	MigratedToID *int    `xml:"migrated_to_id,omitempty"`
	// Name of the LDAP server.
	Name *string `xml:"name,omitempty"`
	// Timeout in seconds.
	OpenCloseTimeout *int `xml:"open_close_timeout,omitempty"`
	Port             *int `xml:"port,omitempty"`
	// Allowed values: see the LdapServerPostConnectionReferralResponse constants.
	ReferralResponse *string `xml:"referral_response,omitempty"`
	// Timeout in seconds.
	SearchTimeout *int `xml:"search_timeout,omitempty"`
	// Allowed values: see the LdapServerPostConnectionServerType constants.
	ServerType   *string `xml:"server_type,omitempty"`
	UseSsl       *bool   `xml:"use_ssl,omitempty"`
	UseWildcards *bool   `xml:"use_wildcards,omitempty"`
}

LdapServerPostConnection represents a ldap server post connection.

func (LdapServerPostConnection) MarshalXML 

func (t LdapServerPostConnection) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LdapServerPostConnection root element name to the wire value declared by the spec (<connection>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LdapServerPostConnectionAuthenticationType 

type LdapServerPostConnectionAuthenticationType = string

LdapServerPostConnectionAuthenticationType is the set of values accepted by LdapServerPostConnection.AuthenticationType. 

const (
	LdapServerPostConnectionAuthenticationTypeSimple    LdapServerPostConnectionAuthenticationType = "simple"
	LdapServerPostConnectionAuthenticationTypeCramMd5   LdapServerPostConnectionAuthenticationType = "CRAM-MD5"
	LdapServerPostConnectionAuthenticationTypeDigestMd5 LdapServerPostConnectionAuthenticationType = "DIGEST-MD5"
	LdapServerPostConnectionAuthenticationTypeNone      LdapServerPostConnectionAuthenticationType = "none"
)

LdapServerPostConnectionAuthenticationType 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 LdapServerPostConnectionAuthenticationTypeValues 

func LdapServerPostConnectionAuthenticationTypeValues() []LdapServerPostConnectionAuthenticationType

LdapServerPostConnectionAuthenticationTypeValues returns every value the Jamf API accepts for LdapServerPostConnectionAuthenticationType, 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 LdapServerPostConnectionReferralResponse 

type LdapServerPostConnectionReferralResponse = string

LdapServerPostConnectionReferralResponse is the set of values accepted by LdapServerPostConnection.ReferralResponse. 

const (
	LdapServerPostConnectionReferralResponseIgnore LdapServerPostConnectionReferralResponse = "ignore"
	LdapServerPostConnectionReferralResponseFollow LdapServerPostConnectionReferralResponse = "follow"
)

LdapServerPostConnectionReferralResponse 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 LdapServerPostConnectionReferralResponseValues 

func LdapServerPostConnectionReferralResponseValues() []LdapServerPostConnectionReferralResponse

LdapServerPostConnectionReferralResponseValues returns every value the Jamf API accepts for LdapServerPostConnectionReferralResponse, 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 LdapServerPostConnectionServerType 

type LdapServerPostConnectionServerType = string

LdapServerPostConnectionServerType is the set of values accepted by LdapServerPostConnection.ServerType. 

const (
	LdapServerPostConnectionServerTypeActiveDirectory LdapServerPostConnectionServerType = "Active Directory"
	LdapServerPostConnectionServerTypeOpenDirectory   LdapServerPostConnectionServerType = "Open Directory"
	LdapServerPostConnectionServerTypeEDirectory      LdapServerPostConnectionServerType = "eDirectory"
	LdapServerPostConnectionServerTypeCustom          LdapServerPostConnectionServerType = "Custom"
)

LdapServerPostConnectionServerType 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 LdapServerPostConnectionServerTypeValues 

func LdapServerPostConnectionServerTypeValues() []LdapServerPostConnectionServerType

LdapServerPostConnectionServerTypeValues returns every value the Jamf API accepts for LdapServerPostConnectionServerType, 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 LdapServerPostMappingsForUsers 

type LdapServerPostMappingsForUsers struct {
	XMLName                     xml.Name
	ID                          *int                                                   `xml:"id,omitempty"`
	UserGroupMappings           *LdapServerMappingsForUsersUserGroupMappings           `xml:"user_group_mappings,omitempty"`
	UserGroupMembershipMappings *LdapServerMappingsForUsersUserGroupMembershipMappings `xml:"user_group_membership_mappings,omitempty"`
	UserMappings                *LdapServerMappingsForUsersUserMappings                `xml:"user_mappings,omitempty"`
}

LdapServerPostMappingsForUsers represents a ldap server post mappings for users.

func (LdapServerPostMappingsForUsers) MarshalXML 

func (t LdapServerPostMappingsForUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LdapServerPostMappingsForUsers root element name to the wire value declared by the spec (<mappings_for_users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LdapServers 

type LdapServers struct {
	XMLName     xml.Name
	Size        *Size    `xml:"size,omitempty"`
	LdapServers []IDName `xml:"ldap_server"`
}

LdapServers wraps a Jamf Classic list response with a flat slice of IDName.

func (LdapServers) MarshalXML 

func (t LdapServers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LdapServers root element name to the wire value declared by the spec (<ldap_servers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LdapServersItem 

type LdapServersItem struct {
	XMLName    xml.Name
	ID         *int    `xml:"id,omitempty"`
	LdapServer *IDName `xml:"ldap_server,omitempty"`
	Size       *Size   `xml:"size,omitempty"`
}

LdapServersItem represents a ldap servers item.

func (LdapServersItem) MarshalXML 

func (t LdapServersItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LdapServersItem root element name to the wire value declared by the spec (<ldap_server>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LicensedSoftware 

type LicensedSoftware struct {
	XMLName             xml.Name
	ID                  *int                                 `xml:"id,omitempty"`
	Computers           *LicensedSoftwareComputers           `xml:"computers,omitempty"`
	FontDefinitions     *LicensedSoftwareFontDefinitions     `xml:"font_definitions,omitempty"`
	General             *LicensedSoftwareGeneral             `xml:"general,omitempty"`
	Licenses            *LicensedSoftwareLicenses            `xml:"licenses,omitempty"`
	PluginDefinitions   *LicensedSoftwarePluginDefinitions   `xml:"plugin_definitions,omitempty"`
	SoftwareDefinitions *LicensedSoftwareSoftwareDefinitions `xml:"software_definitions,omitempty"`
}

LicensedSoftware represents a licensed software.

func (LicensedSoftware) MarshalXML 

func (t LicensedSoftware) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LicensedSoftware root element name to the wire value declared by the spec (<licensed_software>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LicensedSoftwareAll 

type LicensedSoftwareAll struct {
	XMLName           xml.Name
	LicensedSoftwares []LicensedSoftwareAllItemLicensedSoftware `xml:"licensed_software"`
}

LicensedSoftwareAll wraps a Jamf Classic list response with a flat slice of LicensedSoftwareAllItemLicensedSoftware.

func (LicensedSoftwareAll) MarshalXML 

func (t LicensedSoftwareAll) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LicensedSoftwareAll root element name to the wire value declared by the spec (<licensed_software_all>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LicensedSoftwareAllItem 

type LicensedSoftwareAllItem struct {
	XMLName          xml.Name
	ID               *int                                     `xml:"id,omitempty"`
	LicensedSoftware *LicensedSoftwareAllItemLicensedSoftware `xml:"licensed_software,omitempty"`
}

LicensedSoftwareAllItem represents a licensed software all item.

func (LicensedSoftwareAllItem) MarshalXML 

func (t LicensedSoftwareAllItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LicensedSoftwareAllItem root element name to the wire value declared by the spec (<licensed_software_all>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LicensedSoftwareAllItemLicensedSoftware 

type LicensedSoftwareAllItemLicensedSoftware struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the licensed software.
	Name *string `xml:"name,omitempty"`
}

LicensedSoftwareAllItemLicensedSoftware represents a licensed software all item licensed software.

func (LicensedSoftwareAllItemLicensedSoftware) MarshalXML 

func (t LicensedSoftwareAllItemLicensedSoftware) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LicensedSoftwareAllItemLicensedSoftware root element name to the wire value declared by the spec (<licensed_software>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LicensedSoftwareComputers 

type LicensedSoftwareComputers struct {
	XMLName  xml.Name
	Computer *[]LicensedSoftwareComputersComputerItem `xml:"computer,omitempty"`
}

LicensedSoftwareComputers represents a licensed software computers.

func (LicensedSoftwareComputers) MarshalXML 

func (t LicensedSoftwareComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LicensedSoftwareComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LicensedSoftwareComputersComputerItem 

type LicensedSoftwareComputersComputerItem struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
	UDID    *string `xml:"udid,omitempty"`
}

LicensedSoftwareComputersComputerItem represents a licensed software computers computer item.

func (LicensedSoftwareComputersComputerItem) MarshalXML 

func (t LicensedSoftwareComputersComputerItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LicensedSoftwareComputersComputerItem root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LicensedSoftwareDefintion 

type LicensedSoftwareDefintion struct {
	XMLName xml.Name
	// Allowed values: see the LicensedSoftwareDefintionCompareType constants.
	CompareType *string `xml:"compare_type,omitempty"`
	Name        *string `xml:"name,omitempty"`
	Version     *string `xml:"version,omitempty"`
}

LicensedSoftwareDefintion represents a licensed software defintion.

func (LicensedSoftwareDefintion) MarshalXML 

func (t LicensedSoftwareDefintion) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LicensedSoftwareDefintion root element name to the wire value declared by the spec (<definition>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LicensedSoftwareDefintionCompareType 

type LicensedSoftwareDefintionCompareType = string

LicensedSoftwareDefintionCompareType is the set of values accepted by LicensedSoftwareDefintion.CompareType. 

const (
	LicensedSoftwareDefintionCompareTypeLike LicensedSoftwareDefintionCompareType = "like"
	LicensedSoftwareDefintionCompareTypeIs   LicensedSoftwareDefintionCompareType = "is"
)

LicensedSoftwareDefintionCompareType 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 LicensedSoftwareDefintionCompareTypeValues 

func LicensedSoftwareDefintionCompareTypeValues() []LicensedSoftwareDefintionCompareType

LicensedSoftwareDefintionCompareTypeValues returns every value the Jamf API accepts for LicensedSoftwareDefintionCompareType, 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 LicensedSoftwareFontDefinitions 

type LicensedSoftwareFontDefinitions struct {
	XMLName    xml.Name
	Definition *[]LicensedSoftwareDefintion `xml:"definition,omitempty"`
}

LicensedSoftwareFontDefinitions represents a licensed software font definitions.

func (LicensedSoftwareFontDefinitions) MarshalXML 

func (t LicensedSoftwareFontDefinitions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LicensedSoftwareFontDefinitions root element name to the wire value declared by the spec (<font_definitions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LicensedSoftwareGeneral 

type LicensedSoftwareGeneral struct {
	XMLName                            xml.Name
	ExcludeTitlesPurchasedFromAppStore *bool `xml:"exclude_titles_purchased_from_app_store,omitempty"`
	ID                                 *int  `xml:"id,omitempty"`
	// Name of the licensed software.
	Name                             *string     `xml:"name,omitempty"`
	Notes                            *string     `xml:"notes,omitempty"`
	Platform                         *string     `xml:"platform,omitempty"`
	Publisher                        *string     `xml:"publisher,omitempty"`
	RemoveTitlesFromInventoryReports *bool       `xml:"remove_titles_from_inventory_reports,omitempty"`
	SendEmailOnViolation             *bool       `xml:"send_email_on_violation,omitempty"`
	Site                             *SiteObject `xml:"site,omitempty"`
}

LicensedSoftwareGeneral represents a licensed software general.

func (LicensedSoftwareGeneral) MarshalXML 

func (t LicensedSoftwareGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LicensedSoftwareGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LicensedSoftwareLicenses 

type LicensedSoftwareLicenses struct {
	XMLName xml.Name
	License *[]LicensedSoftwareLicensesLicenseItem `xml:"license,omitempty"`
	Size    *Size                                  `xml:"size,omitempty"`
}

LicensedSoftwareLicenses represents a licensed software licenses.

func (LicensedSoftwareLicenses) MarshalXML 

func (t LicensedSoftwareLicenses) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LicensedSoftwareLicenses root element name to the wire value declared by the spec (<licenses>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LicensedSoftwareLicensesLicenseItem 

type LicensedSoftwareLicensesLicenseItem struct {
	XMLName      xml.Name
	ID           *int                                            `xml:"id,omitempty"`
	Attachments  *LicensedSoftwareLicensesLicenseItemAttachments `xml:"attachments,omitempty"`
	LicenseCount *int                                            `xml:"license_count,omitempty"`
	// Allowed values: see the LicensedSoftwareLicensesLicenseItemLicenseType constants.
	LicenseType      *string                                        `xml:"license_type,omitempty"`
	Notes            *string                                        `xml:"notes,omitempty"`
	OrganizationName *string                                        `xml:"organization_name,omitempty"`
	Purchasing       *LicensedSoftwareLicensesLicenseItemPurchasing `xml:"purchasing,omitempty"`
	RegisteredTo     *string                                        `xml:"registered_to,omitempty"`
	SerialNumber1    *string                                        `xml:"serial_number_1,omitempty"`
	SerialNumber2    *string                                        `xml:"serial_number_2,omitempty"`
}

LicensedSoftwareLicensesLicenseItem represents a licensed software licenses license item.

func (LicensedSoftwareLicensesLicenseItem) MarshalXML 

func (t LicensedSoftwareLicensesLicenseItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LicensedSoftwareLicensesLicenseItem root element name to the wire value declared by the spec (<license>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LicensedSoftwareLicensesLicenseItemAttachments 

type LicensedSoftwareLicensesLicenseItemAttachments struct {
	XMLName    xml.Name
	Attachment *[]Attachment `xml:"attachment,omitempty"`
}

LicensedSoftwareLicensesLicenseItemAttachments represents a licensed software licenses license item attachments.

func (LicensedSoftwareLicensesLicenseItemAttachments) MarshalXML 

func (t LicensedSoftwareLicensesLicenseItemAttachments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LicensedSoftwareLicensesLicenseItemAttachments root element name to the wire value declared by the spec (<attachments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LicensedSoftwareLicensesLicenseItemLicenseType 

type LicensedSoftwareLicensesLicenseItemLicenseType = string

LicensedSoftwareLicensesLicenseItemLicenseType is the set of values accepted by LicensedSoftwareLicensesLicenseItem.LicenseType. 

const (
	LicensedSoftwareLicensesLicenseItemLicenseTypeStandard    LicensedSoftwareLicensesLicenseItemLicenseType = "Standard"
	LicensedSoftwareLicensesLicenseItemLicenseTypeConcurrent  LicensedSoftwareLicensesLicenseItemLicenseType = "Concurrent"
	LicensedSoftwareLicensesLicenseItemLicenseTypeSiteLicense LicensedSoftwareLicensesLicenseItemLicenseType = "Site License"
)

LicensedSoftwareLicensesLicenseItemLicenseType 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 LicensedSoftwareLicensesLicenseItemLicenseTypeValues 

func LicensedSoftwareLicensesLicenseItemLicenseTypeValues() []LicensedSoftwareLicensesLicenseItemLicenseType

LicensedSoftwareLicensesLicenseItemLicenseTypeValues returns every value the Jamf API accepts for LicensedSoftwareLicensesLicenseItemLicenseType, 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 LicensedSoftwareLicensesLicenseItemPurchasing 

type LicensedSoftwareLicensesLicenseItemPurchasing struct {
	XMLName             xml.Name
	IsAnnual            *bool   `xml:"is_annual,omitempty"`
	IsPerpetual         *bool   `xml:"is_perpetual,omitempty"`
	LicenseExpires      *string `xml:"license_expires,omitempty"`
	LicenseExpiresEpoch *int    `xml:"license_expires_epoch,omitempty"`
	LicenseExpiresUtc   *string `xml:"license_expires_utc,omitempty"`
	LifeExpectancy      *int    `xml:"life_expectancy,omitempty"`
	PoDate              *string `xml:"po_date,omitempty"`
	PoDateEpoch         *int    `xml:"po_date_epoch,omitempty"`
	PoDateUtc           *string `xml:"po_date_utc,omitempty"`
	PoNumber            *string `xml:"po_number,omitempty"`
	PurchasePrice       *string `xml:"purchase_price,omitempty"`
	PurchasingAccount   *string `xml:"purchasing_account,omitempty"`
	PurchasingContact   *string `xml:"purchasing_contact,omitempty"`
	Vendor              *string `xml:"vendor,omitempty"`
}

LicensedSoftwareLicensesLicenseItemPurchasing represents a licensed software licenses license item purchasing.

func (LicensedSoftwareLicensesLicenseItemPurchasing) MarshalXML 

func (t LicensedSoftwareLicensesLicenseItemPurchasing) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LicensedSoftwareLicensesLicenseItemPurchasing root element name to the wire value declared by the spec (<purchasing>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LicensedSoftwarePluginDefinitions 

type LicensedSoftwarePluginDefinitions struct {
	XMLName    xml.Name
	Definition *[]LicensedSoftwareDefintion `xml:"definition,omitempty"`
}

LicensedSoftwarePluginDefinitions represents a licensed software plugin definitions.

func (LicensedSoftwarePluginDefinitions) MarshalXML 

func (t LicensedSoftwarePluginDefinitions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LicensedSoftwarePluginDefinitions root element name to the wire value declared by the spec (<plugin_definitions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LicensedSoftwareSoftwareDefinitions 

type LicensedSoftwareSoftwareDefinitions struct {
	XMLName    xml.Name
	Definition *[]LicensedSoftwareDefintion `xml:"definition,omitempty"`
}

LicensedSoftwareSoftwareDefinitions represents a licensed software software definitions.

func (LicensedSoftwareSoftwareDefinitions) MarshalXML 

func (t LicensedSoftwareSoftwareDefinitions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LicensedSoftwareSoftwareDefinitions root element name to the wire value declared by the spec (<software_definitions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Location 

type Location struct {
	XMLName      xml.Name
	Building     *string `xml:"building,omitempty"`
	Department   *string `xml:"department,omitempty"`
	EmailAddress *string `xml:"email_address,omitempty"`
	Phone        *string `xml:"phone,omitempty"`
	PhoneNumber  *string `xml:"phone_number,omitempty"`
	Position     *string `xml:"position,omitempty"`
	RealName     *string `xml:"real_name,omitempty"`
	Realname     *string `xml:"realname,omitempty"`
	Room         *string `xml:"room,omitempty"`
	Username     *string `xml:"username,omitempty"`
}

Location represents a location.

func (Location) MarshalXML 

func (t Location) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Location root element name to the wire value declared by the spec (<location>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Logflush 

type Logflush struct {
	XMLName   xml.Name
	ID        *int               `xml:"id,omitempty"`
	Computers *LogflushComputers `xml:"computers,omitempty"`
	// Allowed values: see the LogflushInterval constants.
	Interval *string `xml:"interval,omitempty"`
	// Allowed values: see the LogflushLog constants.
	Log   *string `xml:"log,omitempty"`
	LogID *int    `xml:"log_id,omitempty"`
}

Logflush represents a logflush.

func (Logflush) MarshalXML 

func (t Logflush) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Logflush root element name to the wire value declared by the spec (<logflush>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LogflushComputers 

type LogflushComputers struct {
	XMLName  xml.Name
	ID       *int                       `xml:"id,omitempty"`
	Computer *LogflushComputersComputer `xml:"computer,omitempty"`
}

LogflushComputers represents a logflush computers.

func (LogflushComputers) MarshalXML 

func (t LogflushComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LogflushComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LogflushComputersComputer 

type LogflushComputersComputer struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
}

LogflushComputersComputer represents a logflush computers computer.

func (LogflushComputersComputer) MarshalXML 

func (t LogflushComputersComputer) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the LogflushComputersComputer root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type LogflushInterval 

type LogflushInterval = string

LogflushInterval is the set of values accepted by Logflush.Interval. 

const (
	LogflushIntervalZeroDays    LogflushInterval = "Zero Days"
	LogflushIntervalZeroWeeks   LogflushInterval = "Zero Weeks"
	LogflushIntervalZeroMonths  LogflushInterval = "Zero Months"
	LogflushIntervalZeroYears   LogflushInterval = "Zero Years"
	LogflushIntervalOneDays     LogflushInterval = "One Days"
	LogflushIntervalOneWeeks    LogflushInterval = "One Weeks"
	LogflushIntervalOneMonths   LogflushInterval = "One Months"
	LogflushIntervalOneYears    LogflushInterval = "One Years"
	LogflushIntervalTwoDays     LogflushInterval = "Two Days"
	LogflushIntervalTwoWeeks    LogflushInterval = "Two Weeks"
	LogflushIntervalTwoMonths   LogflushInterval = "Two Months"
	LogflushIntervalTwoYears    LogflushInterval = "Two Years"
	LogflushIntervalThreeDays   LogflushInterval = "Three Days"
	LogflushIntervalThreeWeeks  LogflushInterval = "Three Weeks"
	LogflushIntervalThreeMonths LogflushInterval = "Three Months"
	LogflushIntervalThreeYears  LogflushInterval = "Three Years"
	LogflushIntervalSixDays     LogflushInterval = "Six Days"
	LogflushIntervalSixWeeks    LogflushInterval = "Six Weeks"
	LogflushIntervalSixMonths   LogflushInterval = "Six Months"
	LogflushIntervalSixYears    LogflushInterval = "Six Years"
)

LogflushInterval 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 LogflushIntervalValues 

func LogflushIntervalValues() []LogflushInterval

LogflushIntervalValues returns every value the Jamf API accepts for LogflushInterval, 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 LogflushLog 

type LogflushLog = string

LogflushLog is the set of values accepted by Logflush.Log. 

const (
	LogflushLogPolicy LogflushLog = "policy"
)

LogflushLog 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 LogflushLogValues 

func LogflushLogValues() []LogflushLog

LogflushLogValues returns every value the Jamf API accepts for LogflushLog, 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 MacApplication 

type MacApplication struct {
	XMLName     xml.Name
	ID          *int                       `xml:"id,omitempty"`
	General     *MacApplicationGeneral     `xml:"general,omitempty"`
	Scope       *MacApplicationScope       `xml:"scope,omitempty"`
	SelfService *MacApplicationSelfService `xml:"self_service,omitempty"`
	Vpp         *MacApplicationVpp         `xml:"vpp,omitempty"`
}

MacApplication represents a mac application.

func (MacApplication) MarshalXML 

func (t MacApplication) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplication root element name to the wire value declared by the spec (<mac_application>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationGeneral 

type MacApplicationGeneral struct {
	XMLName        xml.Name
	BundleID       *string         `xml:"bundle_id,omitempty"`
	Category       *CategoryObject `xml:"category,omitempty"`
	DeploymentType *string         `xml:"deployment_type,omitempty"`
	ID             *int            `xml:"id,omitempty"`
	IsFree         *bool           `xml:"is_free,omitempty"`
	// Name of the application.
	Name    *string     `xml:"name,omitempty"`
	Site    *SiteObject `xml:"site,omitempty"`
	URL     *string     `xml:"url,omitempty"`
	Version *string     `xml:"version,omitempty"`
}

MacApplicationGeneral represents a mac application general.

func (MacApplicationGeneral) MarshalXML 

func (t MacApplicationGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScope 

type MacApplicationScope struct {
	XMLName        xml.Name
	ID             *int                               `xml:"id,omitempty"`
	AllComputers   *bool                              `xml:"all_computers,omitempty"`
	AllJssUsers    *bool                              `xml:"all_jss_users,omitempty"`
	Buildings      *MacApplicationScopeBuildings      `xml:"buildings,omitempty"`
	ComputerGroups *MacApplicationScopeComputerGroups `xml:"computer_groups,omitempty"`
	Computers      *MacApplicationScopeComputers      `xml:"computers,omitempty"`
	Departments    *MacApplicationScopeDepartments    `xml:"departments,omitempty"`
	Exclusions     *MacApplicationScopeExclusions     `xml:"exclusions,omitempty"`
	JssUserGroups  *MacApplicationScopeJssUserGroups  `xml:"jss_user_groups,omitempty"`
	JssUsers       *MacApplicationScopeJssUsers       `xml:"jss_users,omitempty"`
	Limitations    *MacApplicationScopeLimitations    `xml:"limitations,omitempty"`
}

MacApplicationScope represents a mac application scope.

func (MacApplicationScope) MarshalXML 

func (t MacApplicationScope) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScope root element name to the wire value declared by the spec (<scope>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeBuildings 

type MacApplicationScopeBuildings struct {
	XMLName  xml.Name
	Building *[]IDName `xml:"building,omitempty"`
}

MacApplicationScopeBuildings represents a mac application scope buildings.

func (MacApplicationScopeBuildings) MarshalXML 

func (t MacApplicationScopeBuildings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeBuildings root element name to the wire value declared by the spec (<buildings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeComputerGroups 

type MacApplicationScopeComputerGroups struct {
	XMLName       xml.Name
	ComputerGroup *[]IDName `xml:"computer_group,omitempty"`
}

MacApplicationScopeComputerGroups represents a mac application scope computer groups.

func (MacApplicationScopeComputerGroups) MarshalXML 

func (t MacApplicationScopeComputerGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeComputerGroups root element name to the wire value declared by the spec (<computer_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeComputers 

type MacApplicationScopeComputers struct {
	XMLName  xml.Name
	Computer *[]MacApplicationScopeComputersComputerItem `xml:"computer,omitempty"`
}

MacApplicationScopeComputers represents a mac application scope computers.

func (MacApplicationScopeComputers) MarshalXML 

func (t MacApplicationScopeComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeComputersComputerItem 

type MacApplicationScopeComputersComputerItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the computer.
	Name *string `xml:"name,omitempty"`
	UDID *string `xml:"udid,omitempty"`
}

MacApplicationScopeComputersComputerItem represents a mac application scope computers computer item.

func (MacApplicationScopeComputersComputerItem) MarshalXML 

func (t MacApplicationScopeComputersComputerItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeComputersComputerItem root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeDepartments 

type MacApplicationScopeDepartments struct {
	XMLName    xml.Name
	Department *[]IDName `xml:"department,omitempty"`
}

MacApplicationScopeDepartments represents a mac application scope departments.

func (MacApplicationScopeDepartments) MarshalXML 

func (t MacApplicationScopeDepartments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeDepartments root element name to the wire value declared by the spec (<departments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeExclusions 

type MacApplicationScopeExclusions struct {
	XMLName         xml.Name
	ID              *int                                          `xml:"id,omitempty"`
	Buildings       *MacApplicationScopeExclusionsBuildings       `xml:"buildings,omitempty"`
	ComputerGroups  *MacApplicationScopeExclusionsComputerGroups  `xml:"computer_groups,omitempty"`
	Computers       *MacApplicationScopeExclusionsComputers       `xml:"computers,omitempty"`
	Departments     *MacApplicationScopeExclusionsDepartments     `xml:"departments,omitempty"`
	JssUserGroups   *MacApplicationScopeExclusionsJssUserGroups   `xml:"jss_user_groups,omitempty"`
	JssUsers        *MacApplicationScopeExclusionsJssUsers        `xml:"jss_users,omitempty"`
	NetworkSegments *MacApplicationScopeExclusionsNetworkSegments `xml:"network_segments,omitempty"`
	UserGroups      *MacApplicationScopeExclusionsUserGroups      `xml:"user_groups,omitempty"`
	Users           *MacApplicationScopeExclusionsUsers           `xml:"users,omitempty"`
}

MacApplicationScopeExclusions represents a mac application scope exclusions.

func (MacApplicationScopeExclusions) MarshalXML 

func (t MacApplicationScopeExclusions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeExclusions root element name to the wire value declared by the spec (<exclusions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeExclusionsBuildings 

type MacApplicationScopeExclusionsBuildings struct {
	XMLName  xml.Name
	Building *[]IDName `xml:"building,omitempty"`
}

MacApplicationScopeExclusionsBuildings represents a mac application scope exclusions buildings.

func (MacApplicationScopeExclusionsBuildings) MarshalXML 

func (t MacApplicationScopeExclusionsBuildings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeExclusionsBuildings root element name to the wire value declared by the spec (<buildings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeExclusionsComputerGroups 

type MacApplicationScopeExclusionsComputerGroups struct {
	XMLName       xml.Name
	ComputerGroup *[]IDName `xml:"computer_group,omitempty"`
}

MacApplicationScopeExclusionsComputerGroups represents a mac application scope exclusions computer groups.

func (MacApplicationScopeExclusionsComputerGroups) MarshalXML 

func (t MacApplicationScopeExclusionsComputerGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeExclusionsComputerGroups root element name to the wire value declared by the spec (<computer_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeExclusionsComputers 

type MacApplicationScopeExclusionsComputers struct {
	XMLName  xml.Name
	Computer *[]MacApplicationScopeExclusionsComputersComputerItem `xml:"computer,omitempty"`
}

MacApplicationScopeExclusionsComputers represents a mac application scope exclusions computers.

func (MacApplicationScopeExclusionsComputers) MarshalXML 

func (t MacApplicationScopeExclusionsComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeExclusionsComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeExclusionsComputersComputerItem 

type MacApplicationScopeExclusionsComputersComputerItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the computer.
	Name *string `xml:"name,omitempty"`
	UDID *string `xml:"udid,omitempty"`
}

MacApplicationScopeExclusionsComputersComputerItem represents a mac application scope exclusions computers computer item.

func (MacApplicationScopeExclusionsComputersComputerItem) MarshalXML 

func (t MacApplicationScopeExclusionsComputersComputerItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeExclusionsComputersComputerItem root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeExclusionsDepartments 

type MacApplicationScopeExclusionsDepartments struct {
	XMLName    xml.Name
	Department *[]IDName `xml:"department,omitempty"`
}

MacApplicationScopeExclusionsDepartments represents a mac application scope exclusions departments.

func (MacApplicationScopeExclusionsDepartments) MarshalXML 

func (t MacApplicationScopeExclusionsDepartments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeExclusionsDepartments root element name to the wire value declared by the spec (<departments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeExclusionsJssUserGroups 

type MacApplicationScopeExclusionsJssUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

MacApplicationScopeExclusionsJssUserGroups represents a mac application scope exclusions jss user groups.

func (MacApplicationScopeExclusionsJssUserGroups) MarshalXML 

func (t MacApplicationScopeExclusionsJssUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeExclusionsJssUserGroups root element name to the wire value declared by the spec (<jss_user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeExclusionsJssUsers 

type MacApplicationScopeExclusionsJssUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

MacApplicationScopeExclusionsJssUsers represents a mac application scope exclusions jss users.

func (MacApplicationScopeExclusionsJssUsers) MarshalXML 

func (t MacApplicationScopeExclusionsJssUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeExclusionsJssUsers root element name to the wire value declared by the spec (<jss_users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeExclusionsNetworkSegments 

type MacApplicationScopeExclusionsNetworkSegments struct {
	XMLName        xml.Name
	NetworkSegment *[]MacApplicationScopeExclusionsNetworkSegmentsNetworkSegmentItem `xml:"network_segment,omitempty"`
}

MacApplicationScopeExclusionsNetworkSegments represents a mac application scope exclusions network segments.

func (MacApplicationScopeExclusionsNetworkSegments) MarshalXML 

func (t MacApplicationScopeExclusionsNetworkSegments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeExclusionsNetworkSegments root element name to the wire value declared by the spec (<network_segments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeExclusionsNetworkSegmentsNetworkSegmentItem 

type MacApplicationScopeExclusionsNetworkSegmentsNetworkSegmentItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the network segment.
	Name *string `xml:"name,omitempty"`
	Uid  *string `xml:"uid,omitempty"`
}

MacApplicationScopeExclusionsNetworkSegmentsNetworkSegmentItem represents a mac application scope exclusions network segments network segment item.

func (MacApplicationScopeExclusionsNetworkSegmentsNetworkSegmentItem) MarshalXML 

func (t MacApplicationScopeExclusionsNetworkSegmentsNetworkSegmentItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeExclusionsNetworkSegmentsNetworkSegmentItem root element name to the wire value declared by the spec (<network_segment>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeExclusionsUserGroups 

type MacApplicationScopeExclusionsUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

MacApplicationScopeExclusionsUserGroups represents a mac application scope exclusions user groups.

func (MacApplicationScopeExclusionsUserGroups) MarshalXML 

func (t MacApplicationScopeExclusionsUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeExclusionsUserGroups root element name to the wire value declared by the spec (<user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeExclusionsUsers 

type MacApplicationScopeExclusionsUsers struct {
	XMLName xml.Name
	User    *[]MacApplicationScopeExclusionsUsersUserItem `xml:"user,omitempty"`
}

MacApplicationScopeExclusionsUsers represents a mac application scope exclusions users.

func (MacApplicationScopeExclusionsUsers) MarshalXML 

func (t MacApplicationScopeExclusionsUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeExclusionsUsers root element name to the wire value declared by the spec (<users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeExclusionsUsersUserItem 

type MacApplicationScopeExclusionsUsersUserItem struct {
	XMLName xml.Name
	Name    *string `xml:"name,omitempty"`
}

MacApplicationScopeExclusionsUsersUserItem represents a mac application scope exclusions users user item.

func (MacApplicationScopeExclusionsUsersUserItem) MarshalXML 

func (t MacApplicationScopeExclusionsUsersUserItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeExclusionsUsersUserItem root element name to the wire value declared by the spec (<user>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeJssUserGroups 

type MacApplicationScopeJssUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

MacApplicationScopeJssUserGroups represents a mac application scope jss user groups.

func (MacApplicationScopeJssUserGroups) MarshalXML 

func (t MacApplicationScopeJssUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeJssUserGroups root element name to the wire value declared by the spec (<jss_user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeJssUsers 

type MacApplicationScopeJssUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

MacApplicationScopeJssUsers represents a mac application scope jss users.

func (MacApplicationScopeJssUsers) MarshalXML 

func (t MacApplicationScopeJssUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeJssUsers root element name to the wire value declared by the spec (<jss_users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeLimitations 

type MacApplicationScopeLimitations struct {
	XMLName         xml.Name
	ID              *int                                           `xml:"id,omitempty"`
	NetworkSegments *MacApplicationScopeLimitationsNetworkSegments `xml:"network_segments,omitempty"`
	UserGroups      *MacApplicationScopeLimitationsUserGroups      `xml:"user_groups,omitempty"`
	Users           *MacApplicationScopeLimitationsUsers           `xml:"users,omitempty"`
}

MacApplicationScopeLimitations represents a mac application scope limitations.

func (MacApplicationScopeLimitations) MarshalXML 

func (t MacApplicationScopeLimitations) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeLimitations root element name to the wire value declared by the spec (<limitations>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeLimitationsNetworkSegments 

type MacApplicationScopeLimitationsNetworkSegments struct {
	XMLName        xml.Name
	NetworkSegment *[]IDName `xml:"network_segment,omitempty"`
}

MacApplicationScopeLimitationsNetworkSegments represents a mac application scope limitations network segments.

func (MacApplicationScopeLimitationsNetworkSegments) MarshalXML 

func (t MacApplicationScopeLimitationsNetworkSegments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeLimitationsNetworkSegments root element name to the wire value declared by the spec (<network_segments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeLimitationsUserGroups 

type MacApplicationScopeLimitationsUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

MacApplicationScopeLimitationsUserGroups represents a mac application scope limitations user groups.

func (MacApplicationScopeLimitationsUserGroups) MarshalXML 

func (t MacApplicationScopeLimitationsUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeLimitationsUserGroups root element name to the wire value declared by the spec (<user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationScopeLimitationsUsers 

type MacApplicationScopeLimitationsUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

MacApplicationScopeLimitationsUsers represents a mac application scope limitations users.

func (MacApplicationScopeLimitationsUsers) MarshalXML 

func (t MacApplicationScopeLimitationsUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationScopeLimitationsUsers root element name to the wire value declared by the spec (<users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationSelfService 

type MacApplicationSelfService struct {
	XMLName                     xml.Name
	ID                          *int                                            `xml:"id,omitempty"`
	FeatureOnMainPage           *bool                                           `xml:"feature_on_main_page,omitempty"`
	ForceUsersToViewDescription *bool                                           `xml:"force_users_to_view_description,omitempty"`
	InstallButtonText           *string                                         `xml:"install_button_text,omitempty"`
	Notification                *NotificationValue                              `xml:"notification"`
	NotificationMessage         *string                                         `xml:"notification_message,omitempty"`
	NotificationSubject         *string                                         `xml:"notification_subject,omitempty"`
	SelfServiceCategories       *MacApplicationSelfServiceSelfServiceCategories `xml:"self_service_categories,omitempty"`
	SelfServiceDescription      *string                                         `xml:"self_service_description,omitempty"`
	SelfServiceIcon             *MacApplicationSelfServiceSelfServiceIcon       `xml:"self_service_icon,omitempty"`
}

MacApplicationSelfService represents a mac application self service.

func (MacApplicationSelfService) MarshalXML 

func (t MacApplicationSelfService) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationSelfService root element name to the wire value declared by the spec (<self_service>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationSelfServiceSelfServiceCategories 

type MacApplicationSelfServiceSelfServiceCategories struct {
	XMLName  xml.Name
	Category *[]MacApplicationSelfServiceSelfServiceCategoriesCategoryItem `xml:"category,omitempty"`
}

MacApplicationSelfServiceSelfServiceCategories represents a mac application self service self service categories.

func (MacApplicationSelfServiceSelfServiceCategories) MarshalXML 

func (t MacApplicationSelfServiceSelfServiceCategories) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationSelfServiceSelfServiceCategories root element name to the wire value declared by the spec (<self_service_categories>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationSelfServiceSelfServiceCategoriesCategoryItem 

type MacApplicationSelfServiceSelfServiceCategoriesCategoryItem struct {
	XMLName   xml.Name
	DisplayIn *bool   `xml:"display_in,omitempty"`
	FeatureIn *bool   `xml:"feature_in,omitempty"`
	ID        *int    `xml:"id,omitempty"`
	Name      *string `xml:"name,omitempty"`
}

MacApplicationSelfServiceSelfServiceCategoriesCategoryItem represents a mac application self service self service categories category item.

func (MacApplicationSelfServiceSelfServiceCategoriesCategoryItem) MarshalXML 

func (t MacApplicationSelfServiceSelfServiceCategoriesCategoryItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationSelfServiceSelfServiceCategoriesCategoryItem root element name to the wire value declared by the spec (<category>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationSelfServiceSelfServiceIcon 

type MacApplicationSelfServiceSelfServiceIcon struct {
	XMLName xml.Name
	Data    *string `xml:"data,omitempty"`
	ID      *int    `xml:"id,omitempty"`
	URI     *string `xml:"uri,omitempty"`
}

MacApplicationSelfServiceSelfServiceIcon represents a mac application self service self service icon.

func (MacApplicationSelfServiceSelfServiceIcon) MarshalXML 

func (t MacApplicationSelfServiceSelfServiceIcon) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationSelfServiceSelfServiceIcon root element name to the wire value declared by the spec (<self_service_icon>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationVpp 

type MacApplicationVpp struct {
	XMLName                      xml.Name
	AssignVppDeviceBasedLicenses *bool `xml:"assign_vpp_device_based_licenses,omitempty"`
	RemainingVppLicenses         *int  `xml:"remaining_vpp_licenses,omitempty"`
	TotalVppLicenses             *int  `xml:"total_vpp_licenses,omitempty"`
	UsedVppLicenses              *int  `xml:"used_vpp_licenses,omitempty"`
	VppAdminAccountID            *int  `xml:"vpp_admin_account_id,omitempty"`
}

MacApplicationVpp represents a mac application vpp.

func (MacApplicationVpp) MarshalXML 

func (t MacApplicationVpp) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationVpp root element name to the wire value declared by the spec (<vpp>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplications 

type MacApplications struct {
	XMLName         xml.Name
	MacApplications []MacApplicationsItemMacApplication `xml:"mac_application"`
}

MacApplications wraps a Jamf Classic list response with a flat slice of MacApplicationsItemMacApplication.

func (MacApplications) MarshalXML 

func (t MacApplications) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplications root element name to the wire value declared by the spec (<mac_applications>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationsItem 

type MacApplicationsItem struct {
	XMLName        xml.Name
	ID             *int                               `xml:"id,omitempty"`
	MacApplication *MacApplicationsItemMacApplication `xml:"mac_application,omitempty"`
}

MacApplicationsItem represents a mac applications item.

func (MacApplicationsItem) MarshalXML 

func (t MacApplicationsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationsItem root element name to the wire value declared by the spec (<mac_application>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MacApplicationsItemMacApplication 

type MacApplicationsItemMacApplication struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the application.
	Name *string `xml:"name,omitempty"`
}

MacApplicationsItemMacApplication represents a mac applications item mac application.

func (MacApplicationsItemMacApplication) MarshalXML 

func (t MacApplicationsItemMacApplication) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MacApplicationsItemMacApplication root element name to the wire value declared by the spec (<mac_application>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDevice 

type MobileDevice struct {
	XMLName               xml.Name
	ID                    *int                                   `xml:"id,omitempty"`
	Applications          *MobileDeviceApplications2             `xml:"applications,omitempty"`
	Certificates          *MobileDeviceCertificates              `xml:"certificates,omitempty"`
	ConfigurationProfiles *MobileDeviceConfigurationProfiles2    `xml:"configuration_profiles,omitempty"`
	ExtensionAttributes   *[]MobileDeviceExtensionAttributesItem `xml:"extension_attributes,omitempty"`
	General               *MobileDeviceGeneral                   `xml:"general,omitempty"`
	Location              *Location                              `xml:"location,omitempty"`
	MobileDeviceGroups    *MobileDeviceMobileDeviceGroups        `xml:"mobile_device_groups,omitempty"`
	Network               *MobileDeviceNetwork                   `xml:"network,omitempty"`
	ProvisioningProfiles  *MobileDeviceProvisioningProfiles2     `xml:"provisioning_profiles,omitempty"`
	Purchasing            *Purchasing                            `xml:"purchasing,omitempty"`
	SecurityObject        *MobileDeviceSecurityObject            `xml:"security_object,omitempty"`
}

MobileDevice represents a mobile device.

func (MobileDevice) MarshalXML 

func (t MobileDevice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDevice root element name to the wire value declared by the spec (<mobile_device>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplication 

type MobileDeviceApplication struct {
	XMLName          xml.Name
	ID               *int                                     `xml:"id,omitempty"`
	AppConfiguration *MobileDeviceApplicationAppConfiguration `xml:"app_configuration,omitempty"`
	General          *MobileDeviceApplicationGeneral          `xml:"general,omitempty"`
	Scope            *MobileDeviceApplicationScope            `xml:"scope,omitempty"`
	SelfService      *MobileDeviceApplicationSelfService      `xml:"self_service,omitempty"`
	Vpp              *MobileDeviceApplicationVpp              `xml:"vpp,omitempty"`
}

MobileDeviceApplication represents a mobile device application.

func (MobileDeviceApplication) MarshalXML 

func (t MobileDeviceApplication) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplication root element name to the wire value declared by the spec (<mobile_device_application>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationAppConfiguration 

type MobileDeviceApplicationAppConfiguration struct {
	XMLName     xml.Name
	Preferences *string `xml:"preferences,omitempty"`
}

MobileDeviceApplicationAppConfiguration represents a mobile device application app configuration.

func (MobileDeviceApplicationAppConfiguration) MarshalXML 

func (t MobileDeviceApplicationAppConfiguration) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationAppConfiguration root element name to the wire value declared by the spec (<app_configuration>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationGeneral 

type MobileDeviceApplicationGeneral struct {
	XMLName             xml.Name
	AllowUserToDelete   *bool           `xml:"allow_user_to_delete,omitempty"`
	BundleID            *string         `xml:"bundle_id,omitempty"`
	Category            *CategoryObject `xml:"category,omitempty"`
	DeployAsManagedApp  *bool           `xml:"deploy_as_managed_app,omitempty"`
	DeployAutomatically *bool           `xml:"deploy_automatically,omitempty"`
	// Allowed values: see the MobileDeviceApplicationGeneralDeploymentType constants.
	DeploymentType                   *string                             `xml:"deployment_type,omitempty"`
	Description                      *string                             `xml:"description,omitempty"`
	DisplayName                      *string                             `xml:"display_name,omitempty"`
	ExternalURL                      *string                             `xml:"external_url,omitempty"`
	Free                             *bool                               `xml:"free,omitempty"`
	HostExternally                   *bool                               `xml:"host_externally,omitempty"`
	Icon                             *MobileDeviceApplicationGeneralIcon `xml:"icon,omitempty"`
	ID                               *int                                `xml:"id,omitempty"`
	InternalApp                      *bool                               `xml:"internal_app,omitempty"`
	Ipa                              *MobileDeviceApplicationGeneralIpa  `xml:"ipa,omitempty"`
	ItunesCountryRegion              *string                             `xml:"itunes_country_region,omitempty"`
	ItunesStoreURL                   *string                             `xml:"itunes_store_url,omitempty"`
	ItunesSyncTime                   *int                                `xml:"itunes_sync_time,omitempty"`
	KeepAppUpdatedOnDevices          *bool                               `xml:"keep_app_updated_on_devices,omitempty"`
	KeepDescriptionAndIconUpToDate   *bool                               `xml:"keep_description_and_icon_up_to_date,omitempty"`
	MakeAvailableAfterInstall        *bool                               `xml:"make_available_after_install,omitempty"`
	MobileDeviceProvisioningProfile  *int                                `xml:"mobile_device_provisioning_profile,omitempty"`
	Name                             *string                             `xml:"name,omitempty"`
	OsType                           *string                             `xml:"os_type,omitempty"`
	PreventBackupOfAppData           *bool                               `xml:"prevent_backup_of_app_data,omitempty"`
	RemoveAppWhenMDMProfileIsRemoved *bool                               `xml:"remove_app_when_mdm_profile_is_removed,omitempty"`
	RequireNetworkTethered           *bool                               `xml:"require_network_tethered,omitempty"`
	Site                             *SiteObject                         `xml:"site,omitempty"`
	TakeOverManagement               *bool                               `xml:"take_over_management,omitempty"`
	Version                          *string                             `xml:"version,omitempty"`
}

MobileDeviceApplicationGeneral represents a mobile device application general.

func (MobileDeviceApplicationGeneral) MarshalXML 

func (t MobileDeviceApplicationGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationGeneralDeploymentType 

type MobileDeviceApplicationGeneralDeploymentType = string

MobileDeviceApplicationGeneralDeploymentType is the set of values accepted by MobileDeviceApplicationGeneral.DeploymentType. 

const (
	MobileDeviceApplicationGeneralDeploymentTypeMakeAvailableInSelfService               MobileDeviceApplicationGeneralDeploymentType = "Make Available in Self Service"
	MobileDeviceApplicationGeneralDeploymentTypeInstallAutomaticallyPromptUsersToInstall MobileDeviceApplicationGeneralDeploymentType = "Install Automatically/Prompt Users to Install"
)

MobileDeviceApplicationGeneralDeploymentType 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 MobileDeviceApplicationGeneralDeploymentTypeValues 

func MobileDeviceApplicationGeneralDeploymentTypeValues() []MobileDeviceApplicationGeneralDeploymentType

MobileDeviceApplicationGeneralDeploymentTypeValues returns every value the Jamf API accepts for MobileDeviceApplicationGeneralDeploymentType, 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 MobileDeviceApplicationGeneralIcon 

type MobileDeviceApplicationGeneralIcon struct {
	XMLName xml.Name
	// base64 encoded.
	Data *string `xml:"data,omitempty"`
	ID   *int    `xml:"id,omitempty"`
	Name *string `xml:"name,omitempty"`
	URI  *string `xml:"uri,omitempty"`
}

MobileDeviceApplicationGeneralIcon represents a mobile device application general icon.

func (MobileDeviceApplicationGeneralIcon) MarshalXML 

func (t MobileDeviceApplicationGeneralIcon) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationGeneralIcon root element name to the wire value declared by the spec (<icon>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationGeneralIpa 

type MobileDeviceApplicationGeneralIpa struct {
	XMLName xml.Name
	Data    *string `xml:"data,omitempty"`
	Name    *string `xml:"name,omitempty"`
	URI     *string `xml:"uri,omitempty"`
}

MobileDeviceApplicationGeneralIpa represents a mobile device application general ipa.

func (MobileDeviceApplicationGeneralIpa) MarshalXML 

func (t MobileDeviceApplicationGeneralIpa) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationGeneralIpa root element name to the wire value declared by the spec (<ipa>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScope 

type MobileDeviceApplicationScope struct {
	XMLName            xml.Name
	ID                 *int                                            `xml:"id,omitempty"`
	AllJssUsers        *bool                                           `xml:"all_jss_users,omitempty"`
	AllMobileDevices   *bool                                           `xml:"all_mobile_devices,omitempty"`
	Buildings          *MobileDeviceApplicationScopeBuildings          `xml:"buildings,omitempty"`
	Departments        *MobileDeviceApplicationScopeDepartments        `xml:"departments,omitempty"`
	Exclusions         *MobileDeviceApplicationScopeExclusions         `xml:"exclusions,omitempty"`
	JssUserGroups      *MobileDeviceApplicationScopeJssUserGroups      `xml:"jss_user_groups,omitempty"`
	JssUsers           *MobileDeviceApplicationScopeJssUsers           `xml:"jss_users,omitempty"`
	Limitations        *MobileDeviceApplicationScopeLimitations        `xml:"limitations,omitempty"`
	MobileDeviceGroups *MobileDeviceApplicationScopeMobileDeviceGroups `xml:"mobile_device_groups,omitempty"`
	MobileDevices      *MobileDeviceApplicationScopeMobileDevices      `xml:"mobile_devices,omitempty"`
}

MobileDeviceApplicationScope represents a mobile device application scope.

func (MobileDeviceApplicationScope) MarshalXML 

func (t MobileDeviceApplicationScope) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScope root element name to the wire value declared by the spec (<scope>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeBuildings 

type MobileDeviceApplicationScopeBuildings struct {
	XMLName  xml.Name
	Building *[]IDName `xml:"building,omitempty"`
}

MobileDeviceApplicationScopeBuildings represents a mobile device application scope buildings.

func (MobileDeviceApplicationScopeBuildings) MarshalXML 

func (t MobileDeviceApplicationScopeBuildings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeBuildings root element name to the wire value declared by the spec (<buildings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeDepartments 

type MobileDeviceApplicationScopeDepartments struct {
	XMLName    xml.Name
	Department *[]IDName `xml:"department,omitempty"`
}

MobileDeviceApplicationScopeDepartments represents a mobile device application scope departments.

func (MobileDeviceApplicationScopeDepartments) MarshalXML 

func (t MobileDeviceApplicationScopeDepartments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeDepartments root element name to the wire value declared by the spec (<departments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeExclusions 

type MobileDeviceApplicationScopeExclusions struct {
	XMLName            xml.Name
	ID                 *int                                                      `xml:"id,omitempty"`
	Buildings          *MobileDeviceApplicationScopeExclusionsBuildings          `xml:"buildings,omitempty"`
	Departments        *MobileDeviceApplicationScopeExclusionsDepartments        `xml:"departments,omitempty"`
	JssUserGroups      *MobileDeviceApplicationScopeExclusionsJssUserGroups      `xml:"jss_user_groups,omitempty"`
	JssUsers           *MobileDeviceApplicationScopeExclusionsJssUsers           `xml:"jss_users,omitempty"`
	MobileDeviceGroups *MobileDeviceApplicationScopeExclusionsMobileDeviceGroups `xml:"mobile_device_groups,omitempty"`
	MobileDevices      *MobileDeviceApplicationScopeExclusionsMobileDevices      `xml:"mobile_devices,omitempty"`
	NetworkSegments    *MobileDeviceApplicationScopeExclusionsNetworkSegments    `xml:"network_segments,omitempty"`
	UserGroups         *MobileDeviceApplicationScopeExclusionsUserGroups         `xml:"user_groups,omitempty"`
	Users              *MobileDeviceApplicationScopeExclusionsUsers              `xml:"users,omitempty"`
}

MobileDeviceApplicationScopeExclusions represents a mobile device application scope exclusions.

func (MobileDeviceApplicationScopeExclusions) MarshalXML 

func (t MobileDeviceApplicationScopeExclusions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeExclusions root element name to the wire value declared by the spec (<exclusions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeExclusionsBuildings 

type MobileDeviceApplicationScopeExclusionsBuildings struct {
	XMLName  xml.Name
	Building *[]IDName `xml:"building,omitempty"`
}

MobileDeviceApplicationScopeExclusionsBuildings represents a mobile device application scope exclusions buildings.

func (MobileDeviceApplicationScopeExclusionsBuildings) MarshalXML 

func (t MobileDeviceApplicationScopeExclusionsBuildings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeExclusionsBuildings root element name to the wire value declared by the spec (<buildings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeExclusionsDepartments 

type MobileDeviceApplicationScopeExclusionsDepartments struct {
	XMLName    xml.Name
	Department *[]IDName `xml:"department,omitempty"`
}

MobileDeviceApplicationScopeExclusionsDepartments represents a mobile device application scope exclusions departments.

func (MobileDeviceApplicationScopeExclusionsDepartments) MarshalXML 

func (t MobileDeviceApplicationScopeExclusionsDepartments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeExclusionsDepartments root element name to the wire value declared by the spec (<departments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeExclusionsJssUserGroups 

type MobileDeviceApplicationScopeExclusionsJssUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

MobileDeviceApplicationScopeExclusionsJssUserGroups represents a mobile device application scope exclusions jss user groups.

func (MobileDeviceApplicationScopeExclusionsJssUserGroups) MarshalXML 

func (t MobileDeviceApplicationScopeExclusionsJssUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeExclusionsJssUserGroups root element name to the wire value declared by the spec (<jss_user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeExclusionsJssUsers 

type MobileDeviceApplicationScopeExclusionsJssUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

MobileDeviceApplicationScopeExclusionsJssUsers represents a mobile device application scope exclusions jss users.

func (MobileDeviceApplicationScopeExclusionsJssUsers) MarshalXML 

func (t MobileDeviceApplicationScopeExclusionsJssUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeExclusionsJssUsers root element name to the wire value declared by the spec (<jss_users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeExclusionsMobileDeviceGroups 

type MobileDeviceApplicationScopeExclusionsMobileDeviceGroups struct {
	XMLName           xml.Name
	MobileDeviceGroup *[]IDName `xml:"mobile_device_group,omitempty"`
}

MobileDeviceApplicationScopeExclusionsMobileDeviceGroups represents a mobile device application scope exclusions mobile device groups.

func (MobileDeviceApplicationScopeExclusionsMobileDeviceGroups) MarshalXML 

func (t MobileDeviceApplicationScopeExclusionsMobileDeviceGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeExclusionsMobileDeviceGroups root element name to the wire value declared by the spec (<mobile_device_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeExclusionsMobileDevices 

type MobileDeviceApplicationScopeExclusionsMobileDevices struct {
	XMLName      xml.Name
	MobileDevice *[]MobileDeviceApplicationScopeExclusionsMobileDevicesMobileDeviceItem `xml:"mobile_device,omitempty"`
}

MobileDeviceApplicationScopeExclusionsMobileDevices represents a mobile device application scope exclusions mobile devices.

func (MobileDeviceApplicationScopeExclusionsMobileDevices) MarshalXML 

func (t MobileDeviceApplicationScopeExclusionsMobileDevices) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeExclusionsMobileDevices root element name to the wire value declared by the spec (<mobile_devices>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeExclusionsMobileDevicesMobileDeviceItem 

type MobileDeviceApplicationScopeExclusionsMobileDevicesMobileDeviceItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the device.
	Name           *string `xml:"name,omitempty"`
	UDID           *string `xml:"udid,omitempty"`
	WifiMacAddress *string `xml:"wifi_mac_address,omitempty"`
}

MobileDeviceApplicationScopeExclusionsMobileDevicesMobileDeviceItem represents a mobile device application scope exclusions mobile devices mobile device item.

func (MobileDeviceApplicationScopeExclusionsMobileDevicesMobileDeviceItem) MarshalXML 

func (t MobileDeviceApplicationScopeExclusionsMobileDevicesMobileDeviceItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeExclusionsMobileDevicesMobileDeviceItem root element name to the wire value declared by the spec (<mobile_device>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeExclusionsNetworkSegments 

type MobileDeviceApplicationScopeExclusionsNetworkSegments struct {
	XMLName        xml.Name
	NetworkSegment *[]MobileDeviceApplicationScopeExclusionsNetworkSegmentsNetworkSegmentItem `xml:"network_segment,omitempty"`
}

MobileDeviceApplicationScopeExclusionsNetworkSegments represents a mobile device application scope exclusions network segments.

func (MobileDeviceApplicationScopeExclusionsNetworkSegments) MarshalXML 

func (t MobileDeviceApplicationScopeExclusionsNetworkSegments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeExclusionsNetworkSegments root element name to the wire value declared by the spec (<network_segments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeExclusionsNetworkSegmentsNetworkSegmentItem 

type MobileDeviceApplicationScopeExclusionsNetworkSegmentsNetworkSegmentItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the network segment.
	Name *string `xml:"name,omitempty"`
	Uid  *string `xml:"uid,omitempty"`
}

MobileDeviceApplicationScopeExclusionsNetworkSegmentsNetworkSegmentItem represents a mobile device application scope exclusions network segments network segment item.

func (MobileDeviceApplicationScopeExclusionsNetworkSegmentsNetworkSegmentItem) MarshalXML 

func (t MobileDeviceApplicationScopeExclusionsNetworkSegmentsNetworkSegmentItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeExclusionsNetworkSegmentsNetworkSegmentItem root element name to the wire value declared by the spec (<network_segment>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeExclusionsUserGroups 

type MobileDeviceApplicationScopeExclusionsUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

MobileDeviceApplicationScopeExclusionsUserGroups represents a mobile device application scope exclusions user groups.

func (MobileDeviceApplicationScopeExclusionsUserGroups) MarshalXML 

func (t MobileDeviceApplicationScopeExclusionsUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeExclusionsUserGroups root element name to the wire value declared by the spec (<user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeExclusionsUsers 

type MobileDeviceApplicationScopeExclusionsUsers struct {
	XMLName xml.Name
	User    *[]MobileDeviceApplicationScopeExclusionsUsersUserItem `xml:"user,omitempty"`
}

MobileDeviceApplicationScopeExclusionsUsers represents a mobile device application scope exclusions users.

func (MobileDeviceApplicationScopeExclusionsUsers) MarshalXML 

func (t MobileDeviceApplicationScopeExclusionsUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeExclusionsUsers root element name to the wire value declared by the spec (<users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeExclusionsUsersUserItem 

type MobileDeviceApplicationScopeExclusionsUsersUserItem struct {
	XMLName xml.Name
	Name    *string `xml:"name,omitempty"`
}

MobileDeviceApplicationScopeExclusionsUsersUserItem represents a mobile device application scope exclusions users user item.

func (MobileDeviceApplicationScopeExclusionsUsersUserItem) MarshalXML 

func (t MobileDeviceApplicationScopeExclusionsUsersUserItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeExclusionsUsersUserItem root element name to the wire value declared by the spec (<user>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeJssUserGroups 

type MobileDeviceApplicationScopeJssUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

MobileDeviceApplicationScopeJssUserGroups represents a mobile device application scope jss user groups.

func (MobileDeviceApplicationScopeJssUserGroups) MarshalXML 

func (t MobileDeviceApplicationScopeJssUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeJssUserGroups root element name to the wire value declared by the spec (<jss_user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeJssUsers 

type MobileDeviceApplicationScopeJssUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

MobileDeviceApplicationScopeJssUsers represents a mobile device application scope jss users.

func (MobileDeviceApplicationScopeJssUsers) MarshalXML 

func (t MobileDeviceApplicationScopeJssUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeJssUsers root element name to the wire value declared by the spec (<jss_users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeLimitations 

type MobileDeviceApplicationScopeLimitations struct {
	XMLName         xml.Name
	ID              *int                                                    `xml:"id,omitempty"`
	NetworkSegments *MobileDeviceApplicationScopeLimitationsNetworkSegments `xml:"network_segments,omitempty"`
	UserGroups      *MobileDeviceApplicationScopeLimitationsUserGroups      `xml:"user_groups,omitempty"`
	Users           *MobileDeviceApplicationScopeLimitationsUsers           `xml:"users,omitempty"`
}

MobileDeviceApplicationScopeLimitations represents a mobile device application scope limitations.

func (MobileDeviceApplicationScopeLimitations) MarshalXML 

func (t MobileDeviceApplicationScopeLimitations) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeLimitations root element name to the wire value declared by the spec (<limitations>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeLimitationsNetworkSegments 

type MobileDeviceApplicationScopeLimitationsNetworkSegments struct {
	XMLName        xml.Name
	NetworkSegment *[]IDName `xml:"network_segment,omitempty"`
}

MobileDeviceApplicationScopeLimitationsNetworkSegments represents a mobile device application scope limitations network segments.

func (MobileDeviceApplicationScopeLimitationsNetworkSegments) MarshalXML 

func (t MobileDeviceApplicationScopeLimitationsNetworkSegments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeLimitationsNetworkSegments root element name to the wire value declared by the spec (<network_segments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeLimitationsUserGroups 

type MobileDeviceApplicationScopeLimitationsUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

MobileDeviceApplicationScopeLimitationsUserGroups represents a mobile device application scope limitations user groups.

func (MobileDeviceApplicationScopeLimitationsUserGroups) MarshalXML 

func (t MobileDeviceApplicationScopeLimitationsUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeLimitationsUserGroups root element name to the wire value declared by the spec (<user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeLimitationsUsers 

type MobileDeviceApplicationScopeLimitationsUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

MobileDeviceApplicationScopeLimitationsUsers represents a mobile device application scope limitations users.

func (MobileDeviceApplicationScopeLimitationsUsers) MarshalXML 

func (t MobileDeviceApplicationScopeLimitationsUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeLimitationsUsers root element name to the wire value declared by the spec (<users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeMobileDeviceGroups 

type MobileDeviceApplicationScopeMobileDeviceGroups struct {
	XMLName           xml.Name
	MobileDeviceGroup *[]IDName `xml:"mobile_device_group,omitempty"`
}

MobileDeviceApplicationScopeMobileDeviceGroups represents a mobile device application scope mobile device groups.

func (MobileDeviceApplicationScopeMobileDeviceGroups) MarshalXML 

func (t MobileDeviceApplicationScopeMobileDeviceGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeMobileDeviceGroups root element name to the wire value declared by the spec (<mobile_device_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeMobileDevices 

type MobileDeviceApplicationScopeMobileDevices struct {
	XMLName      xml.Name
	MobileDevice *[]MobileDeviceApplicationScopeMobileDevicesMobileDeviceItem `xml:"mobile_device,omitempty"`
}

MobileDeviceApplicationScopeMobileDevices represents a mobile device application scope mobile devices.

func (MobileDeviceApplicationScopeMobileDevices) MarshalXML 

func (t MobileDeviceApplicationScopeMobileDevices) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeMobileDevices root element name to the wire value declared by the spec (<mobile_devices>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationScopeMobileDevicesMobileDeviceItem 

type MobileDeviceApplicationScopeMobileDevicesMobileDeviceItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the device.
	Name           *string `xml:"name,omitempty"`
	UDID           *string `xml:"udid,omitempty"`
	WifiMacAddress *string `xml:"wifi_mac_address,omitempty"`
}

MobileDeviceApplicationScopeMobileDevicesMobileDeviceItem represents a mobile device application scope mobile devices mobile device item.

func (MobileDeviceApplicationScopeMobileDevicesMobileDeviceItem) MarshalXML 

func (t MobileDeviceApplicationScopeMobileDevicesMobileDeviceItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationScopeMobileDevicesMobileDeviceItem root element name to the wire value declared by the spec (<mobile_device>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationSelfService 

type MobileDeviceApplicationSelfService struct {
	XMLName                           xml.Name
	ID                                *int                                                     `xml:"id,omitempty"`
	FeatureOnMainPage                 *bool                                                    `xml:"feature_on_main_page,omitempty"`
	Notification                      *NotificationValue                                       `xml:"notification"`
	NotificationMessage               *string                                                  `xml:"notification_message,omitempty"`
	NotificationSubject               *string                                                  `xml:"notification_subject,omitempty"`
	SelfServiceAfterInstallButtonText *string                                                  `xml:"self_service_after_install_button_text,omitempty"`
	SelfServiceCategories             *MobileDeviceApplicationSelfServiceSelfServiceCategories `xml:"self_service_categories,omitempty"`
	SelfServiceDescription            *string                                                  `xml:"self_service_description,omitempty"`
	SelfServiceIcon                   *MobileDeviceApplicationSelfServiceSelfServiceIcon       `xml:"self_service_icon,omitempty"`
	SelfServiceInstallButtonText      *string                                                  `xml:"self_service_install_button_text,omitempty"`
}

MobileDeviceApplicationSelfService represents a mobile device application self service.

func (MobileDeviceApplicationSelfService) MarshalXML 

func (t MobileDeviceApplicationSelfService) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationSelfService root element name to the wire value declared by the spec (<self_service>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationSelfServiceSelfServiceCategories 

type MobileDeviceApplicationSelfServiceSelfServiceCategories struct {
	XMLName  xml.Name
	Category *[]MobileDeviceApplicationSelfServiceSelfServiceCategoriesCategoryItem `xml:"category,omitempty"`
}

MobileDeviceApplicationSelfServiceSelfServiceCategories represents a mobile device application self service self service categories.

func (MobileDeviceApplicationSelfServiceSelfServiceCategories) MarshalXML 

func (t MobileDeviceApplicationSelfServiceSelfServiceCategories) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationSelfServiceSelfServiceCategories root element name to the wire value declared by the spec (<self_service_categories>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationSelfServiceSelfServiceCategoriesCategoryItem 

type MobileDeviceApplicationSelfServiceSelfServiceCategoriesCategoryItem struct {
	XMLName   xml.Name
	DisplayIn *bool   `xml:"display_in,omitempty"`
	ID        *int    `xml:"id,omitempty"`
	Name      *string `xml:"name,omitempty"`
}

MobileDeviceApplicationSelfServiceSelfServiceCategoriesCategoryItem represents a mobile device application self service self service categories category item.

func (MobileDeviceApplicationSelfServiceSelfServiceCategoriesCategoryItem) MarshalXML 

func (t MobileDeviceApplicationSelfServiceSelfServiceCategoriesCategoryItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationSelfServiceSelfServiceCategoriesCategoryItem root element name to the wire value declared by the spec (<category>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationSelfServiceSelfServiceIcon 

type MobileDeviceApplicationSelfServiceSelfServiceIcon struct {
	XMLName xml.Name
	// base64 encoded.
	Data     *string `xml:"data,omitempty"`
	Filename *string `xml:"filename,omitempty"`
	ID       *int    `xml:"id,omitempty"`
	Name     *string `xml:"name,omitempty"`
	URI      *string `xml:"uri,omitempty"`
}

MobileDeviceApplicationSelfServiceSelfServiceIcon represents a mobile device application self service self service icon.

func (MobileDeviceApplicationSelfServiceSelfServiceIcon) MarshalXML 

func (t MobileDeviceApplicationSelfServiceSelfServiceIcon) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationSelfServiceSelfServiceIcon root element name to the wire value declared by the spec (<self_service_icon>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationVpp 

type MobileDeviceApplicationVpp struct {
	XMLName                      xml.Name
	AssignVppDeviceBasedLicenses *bool `xml:"assign_vpp_device_based_licenses,omitempty"`
	VppAdminAccountID            *int  `xml:"vpp_admin_account_id,omitempty"`
}

MobileDeviceApplicationVpp represents a mobile device application vpp.

func (MobileDeviceApplicationVpp) MarshalXML 

func (t MobileDeviceApplicationVpp) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationVpp root element name to the wire value declared by the spec (<vpp>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplications 

type MobileDeviceApplications struct {
	XMLName                  xml.Name
	MobileDeviceApplications []MobileDeviceApplicationsItemMobileDeviceApplication `xml:"mobile_device_application"`
}

MobileDeviceApplications wraps a Jamf Classic list response with a flat slice of MobileDeviceApplicationsItemMobileDeviceApplication.

func (MobileDeviceApplications) MarshalXML 

func (t MobileDeviceApplications) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplications root element name to the wire value declared by the spec (<mobile_device_applications>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplications2 

type MobileDeviceApplications2 struct {
	XMLName     xml.Name
	Application *[]MobileDeviceApplications2ApplicationItem `xml:"application,omitempty"`
	Size        *Size                                       `xml:"size,omitempty"`
}

MobileDeviceApplications2 represents a mobile device applications2.

func (MobileDeviceApplications2) MarshalXML 

func (t MobileDeviceApplications2) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplications2 root element name to the wire value declared by the spec (<applications>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplications2ApplicationItem 

type MobileDeviceApplications2ApplicationItem struct {
	XMLName            xml.Name
	ApplicationName    *string `xml:"application_name,omitempty"`
	ApplicationVersion *string `xml:"application_version,omitempty"`
	Identifier         *string `xml:"identifier,omitempty"`
}

MobileDeviceApplications2ApplicationItem represents a mobile device applications2 application item.

func (MobileDeviceApplications2ApplicationItem) MarshalXML 

func (t MobileDeviceApplications2ApplicationItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplications2ApplicationItem root element name to the wire value declared by the spec (<application>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationsItem 

type MobileDeviceApplicationsItem struct {
	XMLName                 xml.Name
	ID                      *int                                                 `xml:"id,omitempty"`
	MobileDeviceApplication *MobileDeviceApplicationsItemMobileDeviceApplication `xml:"mobile_device_application,omitempty"`
}

MobileDeviceApplicationsItem represents a mobile device applications item.

func (MobileDeviceApplicationsItem) MarshalXML 

func (t MobileDeviceApplicationsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationsItem root element name to the wire value declared by the spec (<mobile_device_application>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceApplicationsItemMobileDeviceApplication 

type MobileDeviceApplicationsItemMobileDeviceApplication struct {
	XMLName     xml.Name
	BundleID    *string `xml:"bundle_id,omitempty"`
	DisplayName *string `xml:"display_name,omitempty"`
	ID          *int    `xml:"id,omitempty"`
	InternalApp *bool   `xml:"internal_app,omitempty"`
	Name        *string `xml:"name,omitempty"`
	Version     *string `xml:"version,omitempty"`
}

MobileDeviceApplicationsItemMobileDeviceApplication represents a mobile device applications item mobile device application.

func (MobileDeviceApplicationsItemMobileDeviceApplication) MarshalXML 

func (t MobileDeviceApplicationsItemMobileDeviceApplication) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceApplicationsItemMobileDeviceApplication root element name to the wire value declared by the spec (<mobile_device_application>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceCertificates 

type MobileDeviceCertificates struct {
	XMLName     xml.Name
	Certificate *[]MobileDeviceCertificatesCertificateItem `xml:"certificate,omitempty"`
	Size        *Size                                      `xml:"size,omitempty"`
}

MobileDeviceCertificates represents a mobile device certificates.

func (MobileDeviceCertificates) MarshalXML 

func (t MobileDeviceCertificates) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceCertificates root element name to the wire value declared by the spec (<certificates>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceCertificatesCertificateItem 

type MobileDeviceCertificatesCertificateItem struct {
	XMLName    xml.Name
	CommonName *string `xml:"common_name,omitempty"`
	Identity   *bool   `xml:"identity,omitempty"`
}

MobileDeviceCertificatesCertificateItem represents a mobile device certificates certificate item.

func (MobileDeviceCertificatesCertificateItem) MarshalXML 

func (t MobileDeviceCertificatesCertificateItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceCertificatesCertificateItem root element name to the wire value declared by the spec (<certificate>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceCommand 

type MobileDeviceCommand struct {
	XMLName       xml.Name
	ID            *int                              `xml:"id,omitempty"`
	General       *MobileDeviceCommandGeneral       `xml:"general,omitempty"`
	MobileDevices *MobileDeviceCommandMobileDevices `xml:"mobile_devices,omitempty"`
}

MobileDeviceCommand represents a mobile device command.

func (MobileDeviceCommand) MarshalXML 

func (t MobileDeviceCommand) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceCommand root element name to the wire value declared by the spec (<mobile_device_command>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceCommandGeneral 

type MobileDeviceCommandGeneral struct {
	XMLName          xml.Name
	ApnsResultStatus *string `xml:"apns_result_status,omitempty"`
	Command          *string `xml:"command,omitempty"`
	DateSent         *string `xml:"date_sent,omitempty"`
	DateSentEpoch    *BigInt `xml:"date_sent_epoch"`
	DateSentUtc      *string `xml:"date_sent_utc,omitempty"`
	ID               *int    `xml:"id,omitempty"`
	ProfileID        *int    `xml:"profile_id,omitempty"`
	ProfileUDID      *string `xml:"profile_udid,omitempty"`
	UDID             *string `xml:"udid,omitempty"`
	UUID             *string `xml:"uuid,omitempty"`
}

MobileDeviceCommandGeneral represents a mobile device command general.

func (MobileDeviceCommandGeneral) MarshalXML 

func (t MobileDeviceCommandGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceCommandGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceCommandMobileDevices 

type MobileDeviceCommandMobileDevices struct {
	XMLName      xml.Name
	ID           *int                                          `xml:"id,omitempty"`
	MobileDevice *MobileDeviceCommandMobileDevicesMobileDevice `xml:"mobile_device,omitempty"`
	Size         *Size                                         `xml:"size,omitempty"`
}

MobileDeviceCommandMobileDevices represents a mobile device command mobile devices.

func (MobileDeviceCommandMobileDevices) MarshalXML 

func (t MobileDeviceCommandMobileDevices) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceCommandMobileDevices root element name to the wire value declared by the spec (<mobile_devices>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceCommandMobileDevicesMobileDevice 

type MobileDeviceCommandMobileDevicesMobileDevice struct {
	XMLName        xml.Name
	ID             *int    `xml:"id,omitempty"`
	PhoneNumber    *string `xml:"phone_number,omitempty"`
	SerialNumber   *string `xml:"serial_number,omitempty"`
	UDID           *string `xml:"udid,omitempty"`
	WifiMacAddress *string `xml:"wifi_mac_address,omitempty"`
}

MobileDeviceCommandMobileDevicesMobileDevice represents a mobile device command mobile devices mobile device.

func (MobileDeviceCommandMobileDevicesMobileDevice) MarshalXML 

func (t MobileDeviceCommandMobileDevicesMobileDevice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceCommandMobileDevicesMobileDevice root element name to the wire value declared by the spec (<mobile_device>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceCommandPost 

type MobileDeviceCommandPost struct {
	XMLName       xml.Name
	ID            *int                                  `xml:"id,omitempty"`
	General       *MobileDeviceCommandPostGeneral       `xml:"general,omitempty"`
	MobileDevices *MobileDeviceCommandPostMobileDevices `xml:"mobile_devices,omitempty"`
}

MobileDeviceCommandPost represents a mobile device command post.

func (MobileDeviceCommandPost) MarshalXML 

func (t MobileDeviceCommandPost) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceCommandPost root element name to the wire value declared by the spec (<mobile_device_command>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceCommandPostGeneral 

type MobileDeviceCommandPostGeneral struct {
	XMLName          xml.Name
	ApnsResultStatus *string `xml:"apns_result_status,omitempty"`
	Command          *string `xml:"command,omitempty"`
	DateSent         *string `xml:"date_sent,omitempty"`
	DateSentEpoch    *BigInt `xml:"date_sent_epoch"`
	DateSentUtc      *string `xml:"date_sent_utc,omitempty"`
	ID               *int    `xml:"id,omitempty"`
	ProfileID        *int    `xml:"profile_id,omitempty"`
	ProfileUDID      *string `xml:"profile_udid,omitempty"`
	UDID             *string `xml:"udid,omitempty"`
	UUID             *string `xml:"uuid,omitempty"`
}

MobileDeviceCommandPostGeneral represents a mobile device command post general.

func (MobileDeviceCommandPostGeneral) MarshalXML 

func (t MobileDeviceCommandPostGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceCommandPostGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceCommandPostMobileDevices 

type MobileDeviceCommandPostMobileDevices struct {
	XMLName      xml.Name
	ID           *int                                          `xml:"id,omitempty"`
	MobileDevice *MobileDeviceCommandMobileDevicesMobileDevice `xml:"mobile_device,omitempty"`
	Size         *Size                                         `xml:"size,omitempty"`
}

MobileDeviceCommandPostMobileDevices represents a mobile device command post mobile devices.

func (MobileDeviceCommandPostMobileDevices) MarshalXML 

func (t MobileDeviceCommandPostMobileDevices) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceCommandPostMobileDevices root element name to the wire value declared by the spec (<mobile_devices>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceCommands 

type MobileDeviceCommands = []MobileDeviceCommandsItem

MobileDeviceCommands is a list of MobileDeviceCommandsItem.

type MobileDeviceCommandsItem 

type MobileDeviceCommandsItem struct {
	XMLName             xml.Name
	ID                  *int                                         `xml:"id,omitempty"`
	MobileDeviceCommand *MobileDeviceCommandsItemMobileDeviceCommand `xml:"mobile_device_command,omitempty"`
	MobileDevices       *MobileDeviceCommandsItemMobileDevices       `xml:"mobile_devices,omitempty"`
	Size                *Size                                        `xml:"size,omitempty"`
}

MobileDeviceCommandsItem represents a mobile device commands item.

func (MobileDeviceCommandsItem) MarshalXML 

func (t MobileDeviceCommandsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceCommandsItem root element name to the wire value declared by the spec (<mobile_device_command>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceCommandsItemMobileDeviceCommand 

type MobileDeviceCommandsItemMobileDeviceCommand struct {
	XMLName   xml.Name
	Command   *string `xml:"command,omitempty"`
	ID        *int    `xml:"id,omitempty"`
	ProfileID *int    `xml:"profile_id,omitempty"`
	UDID      *string `xml:"udid,omitempty"`
}

MobileDeviceCommandsItemMobileDeviceCommand represents a mobile device commands item mobile device command.

func (MobileDeviceCommandsItemMobileDeviceCommand) MarshalXML 

func (t MobileDeviceCommandsItemMobileDeviceCommand) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceCommandsItemMobileDeviceCommand root element name to the wire value declared by the spec (<mobile_device_command>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceCommandsItemMobileDevices 

type MobileDeviceCommandsItemMobileDevices struct {
	XMLName      xml.Name
	ID           *int                                               `xml:"id,omitempty"`
	MobileDevice *MobileDeviceCommandsItemMobileDevicesMobileDevice `xml:"mobile_device,omitempty"`
	Size         *Size                                              `xml:"size,omitempty"`
}

MobileDeviceCommandsItemMobileDevices represents a mobile device commands item mobile devices.

func (MobileDeviceCommandsItemMobileDevices) MarshalXML 

func (t MobileDeviceCommandsItemMobileDevices) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceCommandsItemMobileDevices root element name to the wire value declared by the spec (<mobile_devices>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceCommandsItemMobileDevicesMobileDevice 

type MobileDeviceCommandsItemMobileDevicesMobileDevice struct {
	XMLName        xml.Name
	ID             *int    `xml:"id,omitempty"`
	PhoneNumber    *string `xml:"phone_number,omitempty"`
	SerialNumber   *string `xml:"serial_number,omitempty"`
	UDID           *string `xml:"udid,omitempty"`
	WifiMacAddress *string `xml:"wifi_mac_address,omitempty"`
}

MobileDeviceCommandsItemMobileDevicesMobileDevice represents a mobile device commands item mobile devices mobile device.

func (MobileDeviceCommandsItemMobileDevicesMobileDevice) MarshalXML 

func (t MobileDeviceCommandsItemMobileDevicesMobileDevice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceCommandsItemMobileDevicesMobileDevice root element name to the wire value declared by the spec (<mobile_device>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfile 

type MobileDeviceConfigurationProfile struct {
	XMLName     xml.Name
	ID          *int                                         `xml:"id,omitempty"`
	General     *MobileDeviceConfigurationProfileGeneral     `xml:"general,omitempty"`
	Scope       *MobileDeviceConfigurationProfileScope       `xml:"scope,omitempty"`
	SelfService *MobileDeviceConfigurationProfileSelfService `xml:"self_service,omitempty"`
}

MobileDeviceConfigurationProfile represents a mobile device configuration profile.

func (MobileDeviceConfigurationProfile) MarshalXML 

func (t MobileDeviceConfigurationProfile) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfile root element name to the wire value declared by the spec (<configuration_profile>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileGeneral 

type MobileDeviceConfigurationProfileGeneral struct {
	XMLName  xml.Name
	Category *CategoryObject `xml:"category,omitempty"`
	// Allowed values: see the MobileDeviceConfigurationProfileGeneralDeploymentMethod constants.
	DeploymentMethod *string `xml:"deployment_method,omitempty"`
	Description      *string `xml:"description,omitempty"`
	ID               *int    `xml:"id,omitempty"`
	// Level of the configuration profile.
	// Allowed values: see the MobileDeviceConfigurationProfileGeneralLevel constants.
	Level *string `xml:"level,omitempty"`
	// Name of the configuration profile.
	Name                                 *string          `xml:"name,omitempty"`
	Payloads                             *PayloadsXMLText `xml:"payloads,omitempty"`
	RedeployDaysBeforeCertificateExpires *int             `xml:"redeploy_days_before_certificate_expires,omitempty"`
	RedeployOnUpdate                     *string          `xml:"redeploy_on_update,omitempty"`
	Site                                 *SiteObject      `xml:"site,omitempty"`
	UUID                                 *string          `xml:"uuid,omitempty"`
}

MobileDeviceConfigurationProfileGeneral represents a mobile device configuration profile general.

func (MobileDeviceConfigurationProfileGeneral) MarshalXML 

func (t MobileDeviceConfigurationProfileGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileGeneralDeploymentMethod 

type MobileDeviceConfigurationProfileGeneralDeploymentMethod = string

MobileDeviceConfigurationProfileGeneralDeploymentMethod is the set of values accepted by MobileDeviceConfigurationProfileGeneral.DeploymentMethod. 

const (
	MobileDeviceConfigurationProfileGeneralDeploymentMethodInstallAutomatically       MobileDeviceConfigurationProfileGeneralDeploymentMethod = "Install Automatically"
	MobileDeviceConfigurationProfileGeneralDeploymentMethodMakeAvailableInSelfService MobileDeviceConfigurationProfileGeneralDeploymentMethod = "Make Available in Self Service"
)

MobileDeviceConfigurationProfileGeneralDeploymentMethod 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 MobileDeviceConfigurationProfileGeneralDeploymentMethodValues 

func MobileDeviceConfigurationProfileGeneralDeploymentMethodValues() []MobileDeviceConfigurationProfileGeneralDeploymentMethod

MobileDeviceConfigurationProfileGeneralDeploymentMethodValues returns every value the Jamf API accepts for MobileDeviceConfigurationProfileGeneralDeploymentMethod, 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 MobileDeviceConfigurationProfileGeneralLevel 

type MobileDeviceConfigurationProfileGeneralLevel = string

MobileDeviceConfigurationProfileGeneralLevel is the set of values accepted by MobileDeviceConfigurationProfileGeneral.Level. 

const (
	MobileDeviceConfigurationProfileGeneralLevelSystem MobileDeviceConfigurationProfileGeneralLevel = "System"
	MobileDeviceConfigurationProfileGeneralLevelUser   MobileDeviceConfigurationProfileGeneralLevel = "User"
)

MobileDeviceConfigurationProfileGeneralLevel 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 MobileDeviceConfigurationProfileGeneralLevelValues 

func MobileDeviceConfigurationProfileGeneralLevelValues() []MobileDeviceConfigurationProfileGeneralLevel

MobileDeviceConfigurationProfileGeneralLevelValues returns every value the Jamf API accepts for MobileDeviceConfigurationProfileGeneralLevel, 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 MobileDeviceConfigurationProfileScope 

type MobileDeviceConfigurationProfileScope struct {
	XMLName            xml.Name
	ID                 *int                                                     `xml:"id,omitempty"`
	AllJssUsers        *bool                                                    `xml:"all_jss_users,omitempty"`
	AllMobileDevices   *bool                                                    `xml:"all_mobile_devices,omitempty"`
	Buildings          *MobileDeviceConfigurationProfileScopeBuildings          `xml:"buildings,omitempty"`
	Departments        *MobileDeviceConfigurationProfileScopeDepartments        `xml:"departments,omitempty"`
	Exclusions         *MobileDeviceConfigurationProfileScopeExclusions         `xml:"exclusions,omitempty"`
	JssUserGroups      *MobileDeviceConfigurationProfileScopeJssUserGroups      `xml:"jss_user_groups,omitempty"`
	JssUsers           *MobileDeviceConfigurationProfileScopeJssUsers           `xml:"jss_users,omitempty"`
	Limitations        *MobileDeviceConfigurationProfileScopeLimitations        `xml:"limitations,omitempty"`
	MobileDeviceGroups *MobileDeviceConfigurationProfileScopeMobileDeviceGroups `xml:"mobile_device_groups,omitempty"`
	MobileDevices      *MobileDeviceConfigurationProfileScopeMobileDevices      `xml:"mobile_devices,omitempty"`
}

MobileDeviceConfigurationProfileScope represents a mobile device configuration profile scope.

func (MobileDeviceConfigurationProfileScope) MarshalXML 

func (t MobileDeviceConfigurationProfileScope) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScope root element name to the wire value declared by the spec (<scope>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeBuildings 

type MobileDeviceConfigurationProfileScopeBuildings struct {
	XMLName  xml.Name
	Building *[]IDName `xml:"building,omitempty"`
}

MobileDeviceConfigurationProfileScopeBuildings represents a mobile device configuration profile scope buildings.

func (MobileDeviceConfigurationProfileScopeBuildings) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeBuildings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeBuildings root element name to the wire value declared by the spec (<buildings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeDepartments 

type MobileDeviceConfigurationProfileScopeDepartments struct {
	XMLName    xml.Name
	Department *[]IDName `xml:"department,omitempty"`
}

MobileDeviceConfigurationProfileScopeDepartments represents a mobile device configuration profile scope departments.

func (MobileDeviceConfigurationProfileScopeDepartments) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeDepartments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeDepartments root element name to the wire value declared by the spec (<departments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeExclusions 

type MobileDeviceConfigurationProfileScopeExclusions struct {
	XMLName            xml.Name
	ID                 *int                                                               `xml:"id,omitempty"`
	Buildings          *MobileDeviceConfigurationProfileScopeExclusionsBuildings          `xml:"buildings,omitempty"`
	Departments        *MobileDeviceConfigurationProfileScopeExclusionsDepartments        `xml:"departments,omitempty"`
	Ibeacons           *MobileDeviceConfigurationProfileScopeExclusionsIbeacons           `xml:"ibeacons,omitempty"`
	JssUserGroups      *MobileDeviceConfigurationProfileScopeExclusionsJssUserGroups      `xml:"jss_user_groups,omitempty"`
	JssUsers           *MobileDeviceConfigurationProfileScopeExclusionsJssUsers           `xml:"jss_users,omitempty"`
	MobileDeviceGroups *MobileDeviceConfigurationProfileScopeExclusionsMobileDeviceGroups `xml:"mobile_device_groups,omitempty"`
	MobileDevices      *MobileDeviceConfigurationProfileScopeExclusionsMobileDevices      `xml:"mobile_devices,omitempty"`
	NetworkSegments    *MobileDeviceConfigurationProfileScopeExclusionsNetworkSegments    `xml:"network_segments,omitempty"`
	UserGroups         *MobileDeviceConfigurationProfileScopeExclusionsUserGroups         `xml:"user_groups,omitempty"`
	Users              *MobileDeviceConfigurationProfileScopeExclusionsUsers              `xml:"users,omitempty"`
}

MobileDeviceConfigurationProfileScopeExclusions represents a mobile device configuration profile scope exclusions.

func (MobileDeviceConfigurationProfileScopeExclusions) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeExclusions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeExclusions root element name to the wire value declared by the spec (<exclusions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeExclusionsBuildings 

type MobileDeviceConfigurationProfileScopeExclusionsBuildings struct {
	XMLName  xml.Name
	Building *[]IDName `xml:"building,omitempty"`
}

MobileDeviceConfigurationProfileScopeExclusionsBuildings represents a mobile device configuration profile scope exclusions buildings.

func (MobileDeviceConfigurationProfileScopeExclusionsBuildings) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeExclusionsBuildings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeExclusionsBuildings root element name to the wire value declared by the spec (<buildings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeExclusionsDepartments 

type MobileDeviceConfigurationProfileScopeExclusionsDepartments struct {
	XMLName    xml.Name
	Department *[]IDName `xml:"department,omitempty"`
}

MobileDeviceConfigurationProfileScopeExclusionsDepartments represents a mobile device configuration profile scope exclusions departments.

func (MobileDeviceConfigurationProfileScopeExclusionsDepartments) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeExclusionsDepartments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeExclusionsDepartments root element name to the wire value declared by the spec (<departments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeExclusionsIbeacons 

type MobileDeviceConfigurationProfileScopeExclusionsIbeacons struct {
	XMLName xml.Name
	Ibeacon *[]IDName `xml:"ibeacon,omitempty"`
}

MobileDeviceConfigurationProfileScopeExclusionsIbeacons represents a mobile device configuration profile scope exclusions ibeacons.

func (MobileDeviceConfigurationProfileScopeExclusionsIbeacons) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeExclusionsIbeacons) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeExclusionsIbeacons root element name to the wire value declared by the spec (<ibeacons>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeExclusionsJssUserGroups 

type MobileDeviceConfigurationProfileScopeExclusionsJssUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

MobileDeviceConfigurationProfileScopeExclusionsJssUserGroups represents a mobile device configuration profile scope exclusions jss user groups.

func (MobileDeviceConfigurationProfileScopeExclusionsJssUserGroups) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeExclusionsJssUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeExclusionsJssUserGroups root element name to the wire value declared by the spec (<jss_user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeExclusionsJssUsers 

type MobileDeviceConfigurationProfileScopeExclusionsJssUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

MobileDeviceConfigurationProfileScopeExclusionsJssUsers represents a mobile device configuration profile scope exclusions jss users.

func (MobileDeviceConfigurationProfileScopeExclusionsJssUsers) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeExclusionsJssUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeExclusionsJssUsers root element name to the wire value declared by the spec (<jss_users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeExclusionsMobileDeviceGroups 

type MobileDeviceConfigurationProfileScopeExclusionsMobileDeviceGroups struct {
	XMLName           xml.Name
	MobileDeviceGroup *[]IDName `xml:"mobile_device_group,omitempty"`
}

MobileDeviceConfigurationProfileScopeExclusionsMobileDeviceGroups represents a mobile device configuration profile scope exclusions mobile device groups.

func (MobileDeviceConfigurationProfileScopeExclusionsMobileDeviceGroups) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeExclusionsMobileDeviceGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeExclusionsMobileDeviceGroups root element name to the wire value declared by the spec (<mobile_device_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeExclusionsMobileDevices 

type MobileDeviceConfigurationProfileScopeExclusionsMobileDevices struct {
	XMLName      xml.Name
	MobileDevice *[]MobileDeviceConfigurationProfileScopeExclusionsMobileDevicesMobileDeviceItem `xml:"mobile_device,omitempty"`
}

MobileDeviceConfigurationProfileScopeExclusionsMobileDevices represents a mobile device configuration profile scope exclusions mobile devices.

func (MobileDeviceConfigurationProfileScopeExclusionsMobileDevices) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeExclusionsMobileDevices) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeExclusionsMobileDevices root element name to the wire value declared by the spec (<mobile_devices>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeExclusionsMobileDevicesMobileDeviceItem 

type MobileDeviceConfigurationProfileScopeExclusionsMobileDevicesMobileDeviceItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the device.
	Name           *string `xml:"name,omitempty"`
	UDID           *string `xml:"udid,omitempty"`
	WifiMacAddress *string `xml:"wifi_mac_address,omitempty"`
}

MobileDeviceConfigurationProfileScopeExclusionsMobileDevicesMobileDeviceItem represents a mobile device configuration profile scope exclusions mobile devices mobile device item.

func (MobileDeviceConfigurationProfileScopeExclusionsMobileDevicesMobileDeviceItem) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeExclusionsMobileDevicesMobileDeviceItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeExclusionsMobileDevicesMobileDeviceItem root element name to the wire value declared by the spec (<mobile_device>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeExclusionsNetworkSegments 

type MobileDeviceConfigurationProfileScopeExclusionsNetworkSegments struct {
	XMLName        xml.Name
	NetworkSegment *[]MobileDeviceConfigurationProfileScopeExclusionsNetworkSegmentsNetworkSegmentItem `xml:"network_segment,omitempty"`
}

MobileDeviceConfigurationProfileScopeExclusionsNetworkSegments represents a mobile device configuration profile scope exclusions network segments.

func (MobileDeviceConfigurationProfileScopeExclusionsNetworkSegments) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeExclusionsNetworkSegments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeExclusionsNetworkSegments root element name to the wire value declared by the spec (<network_segments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeExclusionsNetworkSegmentsNetworkSegmentItem 

type MobileDeviceConfigurationProfileScopeExclusionsNetworkSegmentsNetworkSegmentItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the network segment.
	Name *string `xml:"name,omitempty"`
	Uid  *string `xml:"uid,omitempty"`
}

MobileDeviceConfigurationProfileScopeExclusionsNetworkSegmentsNetworkSegmentItem represents a mobile device configuration profile scope exclusions network segments network segment item.

func (MobileDeviceConfigurationProfileScopeExclusionsNetworkSegmentsNetworkSegmentItem) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeExclusionsNetworkSegmentsNetworkSegmentItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeExclusionsNetworkSegmentsNetworkSegmentItem root element name to the wire value declared by the spec (<network_segment>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeExclusionsUserGroups 

type MobileDeviceConfigurationProfileScopeExclusionsUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

MobileDeviceConfigurationProfileScopeExclusionsUserGroups represents a mobile device configuration profile scope exclusions user groups.

func (MobileDeviceConfigurationProfileScopeExclusionsUserGroups) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeExclusionsUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeExclusionsUserGroups root element name to the wire value declared by the spec (<user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeExclusionsUsers 

type MobileDeviceConfigurationProfileScopeExclusionsUsers struct {
	XMLName xml.Name
	User    *[]MobileDeviceConfigurationProfileScopeExclusionsUsersUserItem `xml:"user,omitempty"`
}

MobileDeviceConfigurationProfileScopeExclusionsUsers represents a mobile device configuration profile scope exclusions users.

func (MobileDeviceConfigurationProfileScopeExclusionsUsers) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeExclusionsUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeExclusionsUsers root element name to the wire value declared by the spec (<users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeExclusionsUsersUserItem 

type MobileDeviceConfigurationProfileScopeExclusionsUsersUserItem struct {
	XMLName xml.Name
	Name    *string `xml:"name,omitempty"`
}

MobileDeviceConfigurationProfileScopeExclusionsUsersUserItem represents a mobile device configuration profile scope exclusions users user item.

func (MobileDeviceConfigurationProfileScopeExclusionsUsersUserItem) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeExclusionsUsersUserItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeExclusionsUsersUserItem root element name to the wire value declared by the spec (<user>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeJssUserGroups 

type MobileDeviceConfigurationProfileScopeJssUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

MobileDeviceConfigurationProfileScopeJssUserGroups represents a mobile device configuration profile scope jss user groups.

func (MobileDeviceConfigurationProfileScopeJssUserGroups) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeJssUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeJssUserGroups root element name to the wire value declared by the spec (<jss_user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeJssUsers 

type MobileDeviceConfigurationProfileScopeJssUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

MobileDeviceConfigurationProfileScopeJssUsers represents a mobile device configuration profile scope jss users.

func (MobileDeviceConfigurationProfileScopeJssUsers) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeJssUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeJssUsers root element name to the wire value declared by the spec (<jss_users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeLimitations 

type MobileDeviceConfigurationProfileScopeLimitations struct {
	XMLName         xml.Name
	ID              *int                                                             `xml:"id,omitempty"`
	Ibeacons        *MobileDeviceConfigurationProfileScopeLimitationsIbeacons        `xml:"ibeacons,omitempty"`
	NetworkSegments *MobileDeviceConfigurationProfileScopeLimitationsNetworkSegments `xml:"network_segments,omitempty"`
	UserGroups      *MobileDeviceConfigurationProfileScopeLimitationsUserGroups      `xml:"user_groups,omitempty"`
	Users           *MobileDeviceConfigurationProfileScopeLimitationsUsers           `xml:"users,omitempty"`
}

MobileDeviceConfigurationProfileScopeLimitations represents a mobile device configuration profile scope limitations.

func (MobileDeviceConfigurationProfileScopeLimitations) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeLimitations) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeLimitations root element name to the wire value declared by the spec (<limitations>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeLimitationsIbeacons 

type MobileDeviceConfigurationProfileScopeLimitationsIbeacons struct {
	XMLName xml.Name
	Ibeacon *[]IDName `xml:"ibeacon,omitempty"`
}

MobileDeviceConfigurationProfileScopeLimitationsIbeacons represents a mobile device configuration profile scope limitations ibeacons.

func (MobileDeviceConfigurationProfileScopeLimitationsIbeacons) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeLimitationsIbeacons) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeLimitationsIbeacons root element name to the wire value declared by the spec (<ibeacons>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeLimitationsNetworkSegments 

type MobileDeviceConfigurationProfileScopeLimitationsNetworkSegments struct {
	XMLName        xml.Name
	NetworkSegment *[]IDName `xml:"network_segment,omitempty"`
}

MobileDeviceConfigurationProfileScopeLimitationsNetworkSegments represents a mobile device configuration profile scope limitations network segments.

func (MobileDeviceConfigurationProfileScopeLimitationsNetworkSegments) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeLimitationsNetworkSegments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeLimitationsNetworkSegments root element name to the wire value declared by the spec (<network_segments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeLimitationsUserGroups 

type MobileDeviceConfigurationProfileScopeLimitationsUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

MobileDeviceConfigurationProfileScopeLimitationsUserGroups represents a mobile device configuration profile scope limitations user groups.

func (MobileDeviceConfigurationProfileScopeLimitationsUserGroups) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeLimitationsUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeLimitationsUserGroups root element name to the wire value declared by the spec (<user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeLimitationsUsers 

type MobileDeviceConfigurationProfileScopeLimitationsUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

MobileDeviceConfigurationProfileScopeLimitationsUsers represents a mobile device configuration profile scope limitations users.

func (MobileDeviceConfigurationProfileScopeLimitationsUsers) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeLimitationsUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeLimitationsUsers root element name to the wire value declared by the spec (<users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeMobileDeviceGroups 

type MobileDeviceConfigurationProfileScopeMobileDeviceGroups struct {
	XMLName           xml.Name
	MobileDeviceGroup *[]IDName `xml:"mobile_device_group,omitempty"`
}

MobileDeviceConfigurationProfileScopeMobileDeviceGroups represents a mobile device configuration profile scope mobile device groups.

func (MobileDeviceConfigurationProfileScopeMobileDeviceGroups) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeMobileDeviceGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeMobileDeviceGroups root element name to the wire value declared by the spec (<mobile_device_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeMobileDevices 

type MobileDeviceConfigurationProfileScopeMobileDevices struct {
	XMLName      xml.Name
	MobileDevice *[]MobileDeviceConfigurationProfileScopeMobileDevicesMobileDeviceItem `xml:"mobile_device,omitempty"`
}

MobileDeviceConfigurationProfileScopeMobileDevices represents a mobile device configuration profile scope mobile devices.

func (MobileDeviceConfigurationProfileScopeMobileDevices) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeMobileDevices) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeMobileDevices root element name to the wire value declared by the spec (<mobile_devices>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileScopeMobileDevicesMobileDeviceItem 

type MobileDeviceConfigurationProfileScopeMobileDevicesMobileDeviceItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the device.
	Name           *string `xml:"name,omitempty"`
	UDID           *string `xml:"udid,omitempty"`
	WifiMacAddress *string `xml:"wifi_mac_address,omitempty"`
}

MobileDeviceConfigurationProfileScopeMobileDevicesMobileDeviceItem represents a mobile device configuration profile scope mobile devices mobile device item.

func (MobileDeviceConfigurationProfileScopeMobileDevicesMobileDeviceItem) MarshalXML 

func (t MobileDeviceConfigurationProfileScopeMobileDevicesMobileDeviceItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileScopeMobileDevicesMobileDeviceItem root element name to the wire value declared by the spec (<mobile_device>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileSelfService 

type MobileDeviceConfigurationProfileSelfService struct {
	XMLName                xml.Name
	ID                     *int                                                              `xml:"id,omitempty"`
	FeatureOnMainPage      *bool                                                             `xml:"feature_on_main_page,omitempty"`
	Security               *MobileDeviceConfigurationProfileSelfServiceSecurity              `xml:"security,omitempty"`
	SelfServiceCategories  *MobileDeviceConfigurationProfileSelfServiceSelfServiceCategories `xml:"self_service_categories,omitempty"`
	SelfServiceDescription *string                                                           `xml:"self_service_description,omitempty"`
	SelfServiceIcon        *MobileDeviceConfigurationProfileSelfServiceSelfServiceIcon       `xml:"self_service_icon,omitempty"`
}

MobileDeviceConfigurationProfileSelfService represents a mobile device configuration profile self service.

func (MobileDeviceConfigurationProfileSelfService) MarshalXML 

func (t MobileDeviceConfigurationProfileSelfService) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileSelfService root element name to the wire value declared by the spec (<self_service>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileSelfServiceSecurity 

type MobileDeviceConfigurationProfileSelfServiceSecurity struct {
	XMLName           xml.Name
	Password          *string `xml:"password,omitempty"`
	RemovalDisallowed *string `xml:"removal_disallowed,omitempty"`
}

MobileDeviceConfigurationProfileSelfServiceSecurity represents a mobile device configuration profile self service security.

func (MobileDeviceConfigurationProfileSelfServiceSecurity) MarshalXML 

func (t MobileDeviceConfigurationProfileSelfServiceSecurity) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileSelfServiceSecurity root element name to the wire value declared by the spec (<security>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileSelfServiceSelfServiceCategories 

type MobileDeviceConfigurationProfileSelfServiceSelfServiceCategories struct {
	XMLName  xml.Name
	Category *[]MobileDeviceConfigurationProfileSelfServiceSelfServiceCategoriesCategoryItem `xml:"category,omitempty"`
}

MobileDeviceConfigurationProfileSelfServiceSelfServiceCategories represents a mobile device configuration profile self service self service categories.

func (MobileDeviceConfigurationProfileSelfServiceSelfServiceCategories) MarshalXML 

func (t MobileDeviceConfigurationProfileSelfServiceSelfServiceCategories) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileSelfServiceSelfServiceCategories root element name to the wire value declared by the spec (<self_service_categories>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileSelfServiceSelfServiceCategoriesCategoryItem 

type MobileDeviceConfigurationProfileSelfServiceSelfServiceCategoriesCategoryItem struct {
	XMLName xml.Name
	// Required for the category to be stored at all. A <category> carrying only <id>, or <id> plus <name>,
	// or <feature_in> without <display_in>, is silently discarded, and display_in=false is a deletion
	// gesture rather than a stored value. Write-only ON THIS RESOURCE: the GET echoes only <id> and
	// <name>, so no client can read it back or drift-detect it. Do not generalise that —
	// os_x_configuration_profile, policy, ebook, mac_application and mobile_device_application all echo
	// display_in on read, and this is the only one that hides it. Wire-verified on Jamf Pro 11.31.1,
	// 2026-09-07.
	DisplayIn *bool   `xml:"display_in,omitempty"`
	ID        *int    `xml:"id,omitempty"`
	Name      *string `xml:"name,omitempty"`
}

MobileDeviceConfigurationProfileSelfServiceSelfServiceCategoriesCategoryItem represents a mobile device configuration profile self service self service categories category item. `display_in` is the only property that makes the server store the category, and the spec omitted it: it `$ref`ed the shared `category` schema ({id, name, priority}), so this type could not express the write at all. `feature_in` is deliberately absent — the mobile profile's Self Service tab has no per-category "feature in" control, only the single `FeatureOnMainPage` checkbox, and the wire discards a `<category>` carrying `<feature_in>` without `<display_in>` exactly as it discards a bare `<id>`. The sibling `mobile_device_application` agrees on both the spec and the wire: it declares `display_in` and no `feature_in` at the same position, and it stores and echoes `display_in` while storing no `feature_in` at all. The four macOS/ebook siblings do store `feature_in` and echo it defaulted to false, so this is a per-resource capability rather than a field the server ignores everywhere. All six were wire-probed on Jamf Pro 11.31.1, 2026-09-07, with `FeatureOnMainPage` toggled in the same request as the control; the display_in-or-discarded law is identical across all six, and only this resource hides `display_in` from the read.

func (MobileDeviceConfigurationProfileSelfServiceSelfServiceCategoriesCategoryItem) MarshalXML 

func (t MobileDeviceConfigurationProfileSelfServiceSelfServiceCategoriesCategoryItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileSelfServiceSelfServiceCategoriesCategoryItem root element name to the wire value declared by the spec (<category>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfileSelfServiceSelfServiceIcon 

type MobileDeviceConfigurationProfileSelfServiceSelfServiceIcon struct {
	XMLName  xml.Name
	Data     *string `xml:"data,omitempty"`
	Filename *string `xml:"filename,omitempty"`
	URI      *string `xml:"uri,omitempty"`
}

MobileDeviceConfigurationProfileSelfServiceSelfServiceIcon represents a mobile device configuration profile self service self service icon.

func (MobileDeviceConfigurationProfileSelfServiceSelfServiceIcon) MarshalXML 

func (t MobileDeviceConfigurationProfileSelfServiceSelfServiceIcon) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfileSelfServiceSelfServiceIcon root element name to the wire value declared by the spec (<self_service_icon>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfiles 

type MobileDeviceConfigurationProfiles struct {
	XMLName               xml.Name
	ConfigurationProfiles []MobileDeviceConfigurationProfilesItemConfigurationProfile `xml:"configuration_profile"`
}

MobileDeviceConfigurationProfiles wraps a Jamf Classic list response with a flat slice of MobileDeviceConfigurationProfilesItemConfigurationProfile.

func (MobileDeviceConfigurationProfiles) MarshalXML 

func (t MobileDeviceConfigurationProfiles) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfiles root element name to the wire value declared by the spec (<mobile_device_configuration_profiles>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfiles2 

type MobileDeviceConfigurationProfiles2 struct {
	XMLName              xml.Name
	ConfigurationProfile *[]MobileDeviceConfigurationProfiles2ConfigurationProfileItem `xml:"configuration_profile,omitempty"`
	Size                 *Size                                                         `xml:"size,omitempty"`
}

MobileDeviceConfigurationProfiles2 represents a mobile device configuration profiles2.

func (MobileDeviceConfigurationProfiles2) MarshalXML 

func (t MobileDeviceConfigurationProfiles2) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfiles2 root element name to the wire value declared by the spec (<configuration_profiles>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfiles2ConfigurationProfileItem 

type MobileDeviceConfigurationProfiles2ConfigurationProfileItem struct {
	XMLName     xml.Name
	DisplayName *string `xml:"display_name,omitempty"`
	Identifier  *string `xml:"identifier,omitempty"`
	UUID        *string `xml:"uuid,omitempty"`
	Version     *int    `xml:"version,omitempty"`
}

MobileDeviceConfigurationProfiles2ConfigurationProfileItem represents a mobile device configuration profiles2 configuration profile item.

func (MobileDeviceConfigurationProfiles2ConfigurationProfileItem) MarshalXML 

func (t MobileDeviceConfigurationProfiles2ConfigurationProfileItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfiles2ConfigurationProfileItem root element name to the wire value declared by the spec (<configuration_profile>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfilesItem 

type MobileDeviceConfigurationProfilesItem struct {
	XMLName              xml.Name
	ID                   *int                                                       `xml:"id,omitempty"`
	ConfigurationProfile *MobileDeviceConfigurationProfilesItemConfigurationProfile `xml:"configuration_profile,omitempty"`
}

MobileDeviceConfigurationProfilesItem represents a mobile device configuration profiles item.

func (MobileDeviceConfigurationProfilesItem) MarshalXML 

func (t MobileDeviceConfigurationProfilesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfilesItem root element name to the wire value declared by the spec (<mobile_device_configuration_profile>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceConfigurationProfilesItemConfigurationProfile 

type MobileDeviceConfigurationProfilesItemConfigurationProfile struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the configuration profile.
	Name *string `xml:"name,omitempty"`
}

MobileDeviceConfigurationProfilesItemConfigurationProfile represents a mobile device configuration profiles item configuration profile.

func (MobileDeviceConfigurationProfilesItemConfigurationProfile) MarshalXML 

func (t MobileDeviceConfigurationProfilesItemConfigurationProfile) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceConfigurationProfilesItemConfigurationProfile root element name to the wire value declared by the spec (<configuration_profile>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceEnrollmentProfile 

type MobileDeviceEnrollmentProfile struct {
	XMLName     xml.Name
	ID          *int                                      `xml:"id,omitempty"`
	Attachments *MobileDeviceEnrollmentProfileAttachments `xml:"attachments,omitempty"`
	General     *MobileDeviceEnrollmentProfileGeneral     `xml:"general,omitempty"`
	Location    *Location                                 `xml:"location,omitempty"`
	Purchasing  *Purchasing                               `xml:"purchasing,omitempty"`
}

MobileDeviceEnrollmentProfile represents a mobile device enrollment profile.

func (MobileDeviceEnrollmentProfile) MarshalXML 

func (t MobileDeviceEnrollmentProfile) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceEnrollmentProfile root element name to the wire value declared by the spec (<mobile_device_enrollment_profile>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceEnrollmentProfileAttachments 

type MobileDeviceEnrollmentProfileAttachments struct {
	XMLName    xml.Name
	Attachment *[]Attachment `xml:"attachment,omitempty"`
}

MobileDeviceEnrollmentProfileAttachments represents a mobile device enrollment profile attachments.

func (MobileDeviceEnrollmentProfileAttachments) MarshalXML 

func (t MobileDeviceEnrollmentProfileAttachments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceEnrollmentProfileAttachments root element name to the wire value declared by the spec (<attachments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceEnrollmentProfileGeneral 

type MobileDeviceEnrollmentProfileGeneral struct {
	XMLName     xml.Name
	Description *string `xml:"description,omitempty"`
	ID          *int    `xml:"id,omitempty"`
	Invitation  *BigInt `xml:"invitation"`
	// Name of the enrollment profile.
	Name *string     `xml:"name,omitempty"`
	Site *SiteObject `xml:"site,omitempty"`
	UDID *string     `xml:"udid,omitempty"`
	UUID *string     `xml:"uuid,omitempty"`
}

MobileDeviceEnrollmentProfileGeneral represents a mobile device enrollment profile general.

func (MobileDeviceEnrollmentProfileGeneral) MarshalXML 

func (t MobileDeviceEnrollmentProfileGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceEnrollmentProfileGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceEnrollmentProfilePost 

type MobileDeviceEnrollmentProfilePost struct {
	XMLName     xml.Name
	ID          *int                                          `xml:"id,omitempty"`
	Attachments *MobileDeviceEnrollmentProfilePostAttachments `xml:"attachments,omitempty"`
	General     *MobileDeviceEnrollmentProfilePostGeneral     `xml:"general,omitempty"`
	Location    *Location                                     `xml:"location,omitempty"`
	Purchasing  *Purchasing                                   `xml:"purchasing,omitempty"`
}

MobileDeviceEnrollmentProfilePost represents a mobile device enrollment profile post.

func (MobileDeviceEnrollmentProfilePost) MarshalXML 

func (t MobileDeviceEnrollmentProfilePost) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceEnrollmentProfilePost root element name to the wire value declared by the spec (<mobile_device_enrollment_profile>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceEnrollmentProfilePostAttachments 

type MobileDeviceEnrollmentProfilePostAttachments struct {
	XMLName    xml.Name
	Attachment *[]Attachment `xml:"attachment,omitempty"`
}

MobileDeviceEnrollmentProfilePostAttachments represents a mobile device enrollment profile post attachments.

func (MobileDeviceEnrollmentProfilePostAttachments) MarshalXML 

func (t MobileDeviceEnrollmentProfilePostAttachments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceEnrollmentProfilePostAttachments root element name to the wire value declared by the spec (<attachments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceEnrollmentProfilePostGeneral 

type MobileDeviceEnrollmentProfilePostGeneral struct {
	XMLName     xml.Name
	Description *string `xml:"description,omitempty"`
	ID          *int    `xml:"id,omitempty"`
	Invitation  *BigInt `xml:"invitation"`
	// Name of the enrollment profile.
	Name *string     `xml:"name,omitempty"`
	Site *SiteObject `xml:"site,omitempty"`
	UDID *string     `xml:"udid,omitempty"`
	UUID *string     `xml:"uuid,omitempty"`
}

MobileDeviceEnrollmentProfilePostGeneral represents a mobile device enrollment profile post general.

func (MobileDeviceEnrollmentProfilePostGeneral) MarshalXML 

func (t MobileDeviceEnrollmentProfilePostGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceEnrollmentProfilePostGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceEnrollmentProfiles 

type MobileDeviceEnrollmentProfiles struct {
	XMLName                        xml.Name
	Size                           *Size                                                             `xml:"size,omitempty"`
	MobileDeviceEnrollmentProfiles []MobileDeviceEnrollmentProfilesItemMobileDeviceEnrollmentProfile `xml:"mobile_device_enrollment_profile"`
}

MobileDeviceEnrollmentProfiles wraps a Jamf Classic list response with a flat slice of MobileDeviceEnrollmentProfilesItemMobileDeviceEnrollmentProfile.

func (MobileDeviceEnrollmentProfiles) MarshalXML 

func (t MobileDeviceEnrollmentProfiles) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceEnrollmentProfiles root element name to the wire value declared by the spec (<mobile_device_enrollment_profiles>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceEnrollmentProfilesItem 

type MobileDeviceEnrollmentProfilesItem struct {
	XMLName                       xml.Name
	ID                            *int                                                             `xml:"id,omitempty"`
	MobileDeviceEnrollmentProfile *MobileDeviceEnrollmentProfilesItemMobileDeviceEnrollmentProfile `xml:"mobile_device_enrollment_profile,omitempty"`
	Size                          *Size                                                            `xml:"size,omitempty"`
}

MobileDeviceEnrollmentProfilesItem represents a mobile device enrollment profiles item.

func (MobileDeviceEnrollmentProfilesItem) MarshalXML 

func (t MobileDeviceEnrollmentProfilesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceEnrollmentProfilesItem root element name to the wire value declared by the spec (<mobile_device_enrollment_profile>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceEnrollmentProfilesItemMobileDeviceEnrollmentProfile 

type MobileDeviceEnrollmentProfilesItemMobileDeviceEnrollmentProfile struct {
	XMLName    xml.Name
	ID         *int    `xml:"id,omitempty"`
	Invitation *BigInt `xml:"invitation"`
	// Name of the enrollment profile.
	Name *string `xml:"name,omitempty"`
}

MobileDeviceEnrollmentProfilesItemMobileDeviceEnrollmentProfile represents a mobile device enrollment profiles item mobile device enrollment profile.

func (MobileDeviceEnrollmentProfilesItemMobileDeviceEnrollmentProfile) MarshalXML 

func (t MobileDeviceEnrollmentProfilesItemMobileDeviceEnrollmentProfile) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceEnrollmentProfilesItemMobileDeviceEnrollmentProfile root element name to the wire value declared by the spec (<mobile_device_enrollment_profile>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceExtensionAttribute 

type MobileDeviceExtensionAttribute struct {
	XMLName xml.Name
	// Allowed values: see the MobileDeviceExtensionAttributeDataType constants.
	DataType    *string                                  `xml:"data_type,omitempty"`
	Description *string                                  `xml:"description,omitempty"`
	ID          *int                                     `xml:"id,omitempty"`
	InputType   *MobileDeviceExtensionAttributeInputType `xml:"input_type,omitempty"`
	// Allowed values: see the MobileDeviceExtensionAttributeInventoryDisplay constants.
	InventoryDisplay *string `xml:"inventory_display,omitempty"`
	Name             *string `xml:"name,omitempty"`
}

MobileDeviceExtensionAttribute represents a mobile device extension attribute.

func (MobileDeviceExtensionAttribute) MarshalXML 

func (t MobileDeviceExtensionAttribute) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceExtensionAttribute root element name to the wire value declared by the spec (<mobile_device_extension_attribute>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceExtensionAttributeDataType 

type MobileDeviceExtensionAttributeDataType = string

MobileDeviceExtensionAttributeDataType is the set of values accepted by MobileDeviceExtensionAttribute.DataType. 

const (
	MobileDeviceExtensionAttributeDataTypeString  MobileDeviceExtensionAttributeDataType = "String"
	MobileDeviceExtensionAttributeDataTypeDate    MobileDeviceExtensionAttributeDataType = "Date"
	MobileDeviceExtensionAttributeDataTypeInteger MobileDeviceExtensionAttributeDataType = "Integer"
)

MobileDeviceExtensionAttributeDataType 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 MobileDeviceExtensionAttributeDataTypeValues 

func MobileDeviceExtensionAttributeDataTypeValues() []MobileDeviceExtensionAttributeDataType

MobileDeviceExtensionAttributeDataTypeValues returns every value the Jamf API accepts for MobileDeviceExtensionAttributeDataType, 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 MobileDeviceExtensionAttributeInputType 

type MobileDeviceExtensionAttributeInputType struct {
	XMLName      xml.Name
	ID           *int                                                 `xml:"id,omitempty"`
	PopupChoices *MobileDeviceExtensionAttributeInputTypePopupChoices `xml:"popup_choices,omitempty"`
	// Allowed values: see the MobileDeviceExtensionAttributeInputTypeType constants.
	Type *string `xml:"type,omitempty"`
}

MobileDeviceExtensionAttributeInputType represents a mobile device extension attribute input type.

func (MobileDeviceExtensionAttributeInputType) MarshalXML 

func (t MobileDeviceExtensionAttributeInputType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceExtensionAttributeInputType root element name to the wire value declared by the spec (<input_type>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceExtensionAttributeInputTypePopupChoices 

type MobileDeviceExtensionAttributeInputTypePopupChoices struct {
	XMLName xml.Name
	Choice  *[]string `xml:"choice,omitempty"`
}

MobileDeviceExtensionAttributeInputTypePopupChoices represents a mobile device extension attribute input type popup choices.

func (MobileDeviceExtensionAttributeInputTypePopupChoices) MarshalXML 

func (t MobileDeviceExtensionAttributeInputTypePopupChoices) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceExtensionAttributeInputTypePopupChoices root element name to the wire value declared by the spec (<popup_choices>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceExtensionAttributeInputTypeType 

type MobileDeviceExtensionAttributeInputTypeType = string

MobileDeviceExtensionAttributeInputTypeType is the set of values accepted by MobileDeviceExtensionAttributeInputType.Type. 

const (
	MobileDeviceExtensionAttributeInputTypeTypeTextField            MobileDeviceExtensionAttributeInputTypeType = "Text Field"
	MobileDeviceExtensionAttributeInputTypeTypePopUpMenu            MobileDeviceExtensionAttributeInputTypeType = "Pop-up Menu"
	MobileDeviceExtensionAttributeInputTypeTypeLdapAttributeMapping MobileDeviceExtensionAttributeInputTypeType = "LDAP Attribute Mapping"
)

MobileDeviceExtensionAttributeInputTypeType 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 MobileDeviceExtensionAttributeInputTypeTypeValues 

func MobileDeviceExtensionAttributeInputTypeTypeValues() []MobileDeviceExtensionAttributeInputTypeType

MobileDeviceExtensionAttributeInputTypeTypeValues returns every value the Jamf API accepts for MobileDeviceExtensionAttributeInputTypeType, 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 MobileDeviceExtensionAttributeInventoryDisplay 

type MobileDeviceExtensionAttributeInventoryDisplay = string

MobileDeviceExtensionAttributeInventoryDisplay is the set of values accepted by MobileDeviceExtensionAttribute.InventoryDisplay. 

const (
	MobileDeviceExtensionAttributeInventoryDisplayGeneral             MobileDeviceExtensionAttributeInventoryDisplay = "General"
	MobileDeviceExtensionAttributeInventoryDisplayHardware            MobileDeviceExtensionAttributeInventoryDisplay = "Hardware"
	MobileDeviceExtensionAttributeInventoryDisplayUserAndLocation     MobileDeviceExtensionAttributeInventoryDisplay = "User and Location"
	MobileDeviceExtensionAttributeInventoryDisplayPurchasing          MobileDeviceExtensionAttributeInventoryDisplay = "Purchasing"
	MobileDeviceExtensionAttributeInventoryDisplayExtensionAttributes MobileDeviceExtensionAttributeInventoryDisplay = "Extension Attributes"
)

MobileDeviceExtensionAttributeInventoryDisplay 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 MobileDeviceExtensionAttributeInventoryDisplayValues 

func MobileDeviceExtensionAttributeInventoryDisplayValues() []MobileDeviceExtensionAttributeInventoryDisplay

MobileDeviceExtensionAttributeInventoryDisplayValues returns every value the Jamf API accepts for MobileDeviceExtensionAttributeInventoryDisplay, 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 MobileDeviceExtensionAttributes 

type MobileDeviceExtensionAttributes struct {
	XMLName                         xml.Name
	Size                            *Size                                                                `xml:"size,omitempty"`
	MobileDeviceExtensionAttributes []MobileDeviceExtensionAttributesItem2MobileDeviceExtensionAttribute `xml:"mobile_device_extension_attribute"`
}

MobileDeviceExtensionAttributes wraps a Jamf Classic list response with a flat slice of MobileDeviceExtensionAttributesItem2MobileDeviceExtensionAttribute.

func (MobileDeviceExtensionAttributes) MarshalXML 

func (t MobileDeviceExtensionAttributes) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceExtensionAttributes root element name to the wire value declared by the spec (<mobile_device_extension_attributes>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceExtensionAttributesItem 

type MobileDeviceExtensionAttributesItem struct {
	ID    *int    `xml:"id,omitempty"`
	Name  *string `xml:"name,omitempty"`
	Type  *string `xml:"type,omitempty"`
	Value *string `xml:"value,omitempty"`
}

MobileDeviceExtensionAttributesItem represents a mobile device extension attributes item.

type MobileDeviceExtensionAttributesItem2 

type MobileDeviceExtensionAttributesItem2 struct {
	XMLName                        xml.Name
	ID                             *int                                                                `xml:"id,omitempty"`
	MobileDeviceExtensionAttribute *MobileDeviceExtensionAttributesItem2MobileDeviceExtensionAttribute `xml:"mobile_device_extension_attribute,omitempty"`
	Size                           *Size                                                               `xml:"size,omitempty"`
}

MobileDeviceExtensionAttributesItem2 represents a mobile device extension attributes item2.

func (MobileDeviceExtensionAttributesItem2) MarshalXML 

func (t MobileDeviceExtensionAttributesItem2) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceExtensionAttributesItem2 root element name to the wire value declared by the spec (<mobile_device_extension_attribute>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceExtensionAttributesItem2MobileDeviceExtensionAttribute 

type MobileDeviceExtensionAttributesItem2MobileDeviceExtensionAttribute struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
}

MobileDeviceExtensionAttributesItem2MobileDeviceExtensionAttribute represents a mobile device extension attributes item2 mobile device extension attribute.

func (MobileDeviceExtensionAttributesItem2MobileDeviceExtensionAttribute) MarshalXML 

func (t MobileDeviceExtensionAttributesItem2MobileDeviceExtensionAttribute) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceExtensionAttributesItem2MobileDeviceExtensionAttribute root element name to the wire value declared by the spec (<mobile_device_extension_attribute>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceGeneral 

type MobileDeviceGeneral struct {
	XMLName                            xml.Name
	AssetTag                           *string `xml:"asset_tag,omitempty"`
	Available                          *int    `xml:"available,omitempty"`
	AvailableMb                        *int    `xml:"available_mb,omitempty"`
	BatteryLevel                       *int    `xml:"battery_level,omitempty"`
	BleCapable                         *bool   `xml:"ble_capable,omitempty"`
	BluetoothMacAddress                *string `xml:"bluetooth_mac_address,omitempty"`
	Capacity                           *int    `xml:"capacity,omitempty"`
	CapacityMb                         *int    `xml:"capacity_mb,omitempty"`
	CloudBackupEnabled                 *bool   `xml:"cloud_backup_enabled,omitempty"`
	DeviceLocatorServiceEnabled        *bool   `xml:"device_locator_service_enabled,omitempty"`
	DeviceName                         *string `xml:"device_name,omitempty"`
	DeviceOwnershipLevel               *string `xml:"device_ownership_level,omitempty"`
	DisplayName                        *string `xml:"display_name,omitempty"`
	DoNotDisturbEnabled                *bool   `xml:"do_not_disturb_enabled,omitempty"`
	ExchangeActivesyncDeviceIdentifier *string `xml:"exchange_activesync_device_identifier,omitempty"`
	ID                                 *int    `xml:"id,omitempty"`
	InitialEntryDateEpoch              *int    `xml:"initial_entry_date_epoch,omitempty"`
	InitialEntryDateUtc                *string `xml:"initial_entry_date_utc,omitempty"`
	IPAddress                          *string `xml:"ip_address,omitempty"`
	ItunesStoreAccountIsActive         *bool   `xml:"itunes_store_account_is_active,omitempty"`
	LastBackupTimeEpoch                *int    `xml:"last_backup_time_epoch,omitempty"`
	LastBackupTimeUtc                  *string `xml:"last_backup_time_utc,omitempty"`
	LastCloudBackupDateEpoch           *int    `xml:"last_cloud_backup_date_epoch,omitempty"`
	LastCloudBackupDateUtc             *string `xml:"last_cloud_backup_date_utc,omitempty"`
	LastEnrollmentEpoch                *int    `xml:"last_enrollment_epoch,omitempty"`
	LastEnrollmentUtc                  *string `xml:"last_enrollment_utc,omitempty"`
	LastInventoryUpdate                *string `xml:"last_inventory_update,omitempty"`
	LastInventoryUpdateEpoch           *int    `xml:"last_inventory_update_epoch,omitempty"`
	LastInventoryUpdateUtc             *string `xml:"last_inventory_update_utc,omitempty"`
	LocationServicesEnabled            *bool   `xml:"location_services_enabled,omitempty"`
	Managed                            *bool   `xml:"managed,omitempty"`
	Model                              *string `xml:"model,omitempty"`
	ModelDisplay                       *string `xml:"model_display,omitempty"`
	ModelIdentifier                    *string `xml:"model_identifier,omitempty"`
	ModelNumber                        *string `xml:"model_number,omitempty"`
	ModemFirmware                      *string `xml:"modem_firmware,omitempty"`
	Name                               *string `xml:"name,omitempty"`
	OsBuild                            *string `xml:"os_build,omitempty"`
	OsType                             *string `xml:"os_type,omitempty"`
	OsVersion                          *string `xml:"os_version,omitempty"`
	PercentageUsed                     *int    `xml:"percentage_used,omitempty"`
	PhoneNumber                        *string `xml:"phone_number,omitempty"`
	SerialNumber                       *string `xml:"serial_number,omitempty"`
	Shared                             *string `xml:"shared,omitempty"`
	Supervised                         *bool   `xml:"supervised,omitempty"`
	Tethered                           *string `xml:"tethered,omitempty"`
	UDID                               *string `xml:"udid,omitempty"`
	WifiMacAddress                     *string `xml:"wifi_mac_address,omitempty"`
}

MobileDeviceGeneral represents a mobile device general.

func (MobileDeviceGeneral) MarshalXML 

func (t MobileDeviceGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceGroup 

type MobileDeviceGroup struct {
	XMLName       xml.Name
	Criteria      *MobileDeviceGroupCriteria      `xml:"criteria,omitempty"`
	ID            *int                            `xml:"id,omitempty"`
	IsSmart       *bool                           `xml:"is_smart,omitempty"`
	MobileDevices *MobileDeviceGroupMobileDevices `xml:"mobile_devices,omitempty"`
	Name          *string                         `xml:"name,omitempty"`
	Site          *SiteObject                     `xml:"site,omitempty"`
}

MobileDeviceGroup represents a mobile device group.

func (MobileDeviceGroup) MarshalXML 

func (t MobileDeviceGroup) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceGroup root element name to the wire value declared by the spec (<mobile_device_group>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceGroupCriteria 

type MobileDeviceGroupCriteria struct {
	XMLName   xml.Name
	Criterion *[]Criterion `xml:"criterion,omitempty"`
	Size      *Size        `xml:"size,omitempty"`
}

MobileDeviceGroupCriteria represents a mobile device group criteria.

func (MobileDeviceGroupCriteria) MarshalXML 

func (t MobileDeviceGroupCriteria) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceGroupCriteria root element name to the wire value declared by the spec (<criteria>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceGroupMobileDevices 

type MobileDeviceGroupMobileDevices struct {
	XMLName      xml.Name
	MobileDevice *[]MobileDeviceGroupMobileDevicesMobileDeviceItem `xml:"mobile_device,omitempty"`
}

MobileDeviceGroupMobileDevices represents a mobile device group mobile devices.

func (MobileDeviceGroupMobileDevices) MarshalXML 

func (t MobileDeviceGroupMobileDevices) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceGroupMobileDevices root element name to the wire value declared by the spec (<mobile_devices>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceGroupMobileDevicesMobileDeviceItem 

type MobileDeviceGroupMobileDevicesMobileDeviceItem struct {
	XMLName    xml.Name
	ID         *int    `xml:"id,omitempty"`
	MacAddress *string `xml:"mac_address,omitempty"`
	// Name of the device.
	Name           *string `xml:"name,omitempty"`
	SerialNumber   *string `xml:"serial_number,omitempty"`
	UDID           *string `xml:"udid,omitempty"`
	WifiMacAddress *string `xml:"wifi_mac_address,omitempty"`
}

MobileDeviceGroupMobileDevicesMobileDeviceItem represents a mobile device group mobile devices mobile device item.

func (MobileDeviceGroupMobileDevicesMobileDeviceItem) MarshalXML 

func (t MobileDeviceGroupMobileDevicesMobileDeviceItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceGroupMobileDevicesMobileDeviceItem root element name to the wire value declared by the spec (<mobile_device>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceGroups 

type MobileDeviceGroups struct {
	XMLName            xml.Name
	MobileDeviceGroups []MobileDeviceGroupsItemMobileDeviceGroup `xml:"mobile_device_group"`
}

MobileDeviceGroups wraps a Jamf Classic list response with a flat slice of MobileDeviceGroupsItemMobileDeviceGroup.

func (MobileDeviceGroups) MarshalXML 

func (t MobileDeviceGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceGroups root element name to the wire value declared by the spec (<mobile_device_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceGroupsItem 

type MobileDeviceGroupsItem struct {
	XMLName           xml.Name
	ID                *int                                     `xml:"id,omitempty"`
	MobileDeviceGroup *MobileDeviceGroupsItemMobileDeviceGroup `xml:"mobile_device_group,omitempty"`
}

MobileDeviceGroupsItem represents a mobile device groups item.

func (MobileDeviceGroupsItem) MarshalXML 

func (t MobileDeviceGroupsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceGroupsItem root element name to the wire value declared by the spec (<mobile_device_group>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceGroupsItemMobileDeviceGroup 

type MobileDeviceGroupsItemMobileDeviceGroup struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	IsSmart *bool   `xml:"is_smart,omitempty"`
	Name    *string `xml:"name,omitempty"`
}

MobileDeviceGroupsItemMobileDeviceGroup represents a mobile device groups item mobile device group.

func (MobileDeviceGroupsItemMobileDeviceGroup) MarshalXML 

func (t MobileDeviceGroupsItemMobileDeviceGroup) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceGroupsItemMobileDeviceGroup root element name to the wire value declared by the spec (<mobile_device_group>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistory 

type MobileDeviceHistory struct {
	XMLName            xml.Name
	ID                 *int                                   `xml:"id,omitempty"`
	Applications       *MobileDeviceHistoryApplications       `xml:"applications,omitempty"`
	Audits             *MobileDeviceHistoryAudits             `xml:"audits,omitempty"`
	Ebooks             *MobileDeviceHistoryEbooks             `xml:"ebooks,omitempty"`
	General            *MobileDeviceHistoryGeneral            `xml:"general,omitempty"`
	ManagementCommands *MobileDeviceHistoryManagementCommands `xml:"management_commands,omitempty"`
	UserLocation       *MobileDeviceHistoryUserLocation       `xml:"user_location,omitempty"`
}

MobileDeviceHistory represents a mobile device history.

func (MobileDeviceHistory) MarshalXML 

func (t MobileDeviceHistory) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistory root element name to the wire value declared by the spec (<mobile_device_history>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryApp 

type MobileDeviceHistoryApp struct {
	BundleSize  *string `xml:"bundle_size,omitempty"`
	DynamicSize *string `xml:"dynamic_size,omitempty"`
	// Allowed values: see the MobileDeviceHistoryAppManagementStatus constants.
	ManagementStatus *string `xml:"management_status,omitempty"`
	Name             *string `xml:"name,omitempty"`
	Version          *string `xml:"version,omitempty"`
}

MobileDeviceHistoryApp represents a mobile device history app.

type MobileDeviceHistoryAppManagementStatus 

type MobileDeviceHistoryAppManagementStatus = string

MobileDeviceHistoryAppManagementStatus is the set of values accepted by MobileDeviceHistoryApp.ManagementStatus. 

const (
	MobileDeviceHistoryAppManagementStatusUnmanaged MobileDeviceHistoryAppManagementStatus = "Unmanaged"
	MobileDeviceHistoryAppManagementStatusManaged   MobileDeviceHistoryAppManagementStatus = "Managed"
)

MobileDeviceHistoryAppManagementStatus 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 MobileDeviceHistoryAppManagementStatusValues 

func MobileDeviceHistoryAppManagementStatusValues() []MobileDeviceHistoryAppManagementStatus

MobileDeviceHistoryAppManagementStatusValues returns every value the Jamf API accepts for MobileDeviceHistoryAppManagementStatus, 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 MobileDeviceHistoryApplications 

type MobileDeviceHistoryApplications struct {
	XMLName   xml.Name
	ID        *int                                            `xml:"id,omitempty"`
	Failed    *MobileDeviceHistoryApplicationsFailed          `xml:"failed,omitempty"`
	Installed *[]MobileDeviceHistoryApplicationsInstalledItem `xml:"installed,omitempty"`
	Pending   *MobileDeviceHistoryApplicationsPending         `xml:"pending,omitempty"`
}

MobileDeviceHistoryApplications represents a mobile device history applications.

func (MobileDeviceHistoryApplications) MarshalXML 

func (t MobileDeviceHistoryApplications) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryApplications root element name to the wire value declared by the spec (<applications>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryApplicationsFailed 

type MobileDeviceHistoryApplicationsFailed struct {
	XMLName xml.Name
	App     *[]MobileDeviceHistoryApplicationsFailedAppItem `xml:"app,omitempty"`
}

MobileDeviceHistoryApplicationsFailed represents a mobile device history applications failed.

func (MobileDeviceHistoryApplicationsFailed) MarshalXML 

func (t MobileDeviceHistoryApplicationsFailed) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryApplicationsFailed root element name to the wire value declared by the spec (<failed>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryApplicationsFailedAppItem 

type MobileDeviceHistoryApplicationsFailedAppItem struct {
	XMLName          xml.Name
	ManagementStatus *string `xml:"management_status,omitempty"`
	Name             *string `xml:"name,omitempty"`
	Version          *string `xml:"version,omitempty"`
}

MobileDeviceHistoryApplicationsFailedAppItem represents a mobile device history applications failed app item.

func (MobileDeviceHistoryApplicationsFailedAppItem) MarshalXML 

func (t MobileDeviceHistoryApplicationsFailedAppItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryApplicationsFailedAppItem root element name to the wire value declared by the spec (<app>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryApplicationsInstalledItem 

type MobileDeviceHistoryApplicationsInstalledItem struct {
	XMLName                            xml.Name
	ID                                 *int                    `xml:"id,omitempty"`
	AppStoreFromMobileDeviceAppCatalog *MobileDeviceHistoryApp `xml:"app_store_from_mobile_device_app_catalog,omitempty"`
	InHouseFromMobileDeviceAppCatalog  *MobileDeviceHistoryApp `xml:"in_house_from_mobile_device_app_catalog,omitempty"`
	Other                              *MobileDeviceHistoryApp `xml:"other,omitempty"`
}

MobileDeviceHistoryApplicationsInstalledItem represents a mobile device history applications installed item.

func (MobileDeviceHistoryApplicationsInstalledItem) MarshalXML 

func (t MobileDeviceHistoryApplicationsInstalledItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryApplicationsInstalledItem root element name to the wire value declared by the spec (<installed>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryApplicationsPending 

type MobileDeviceHistoryApplicationsPending struct {
	XMLName xml.Name
	App     *[]MobileDeviceHistoryApplicationsPendingAppItem `xml:"app,omitempty"`
}

MobileDeviceHistoryApplicationsPending represents a mobile device history applications pending.

func (MobileDeviceHistoryApplicationsPending) MarshalXML 

func (t MobileDeviceHistoryApplicationsPending) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryApplicationsPending root element name to the wire value declared by the spec (<pending>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryApplicationsPendingAppItem 

type MobileDeviceHistoryApplicationsPendingAppItem struct {
	XMLName          xml.Name
	ManagementStatus *string `xml:"management_status,omitempty"`
	Name             *string `xml:"name,omitempty"`
	Version          *string `xml:"version,omitempty"`
}

MobileDeviceHistoryApplicationsPendingAppItem represents a mobile device history applications pending app item.

func (MobileDeviceHistoryApplicationsPendingAppItem) MarshalXML 

func (t MobileDeviceHistoryApplicationsPendingAppItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryApplicationsPendingAppItem root element name to the wire value declared by the spec (<app>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryAudits 

type MobileDeviceHistoryAudits struct {
	XMLName xml.Name
	Audit   *[]MobileDeviceHistoryAuditsAuditItem `xml:"audit,omitempty"`
}

MobileDeviceHistoryAudits represents a mobile device history audits.

func (MobileDeviceHistoryAudits) MarshalXML 

func (t MobileDeviceHistoryAudits) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryAudits root element name to the wire value declared by the spec (<audits>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryAuditsAuditItem 

type MobileDeviceHistoryAuditsAuditItem struct {
	XMLName       xml.Name
	DateTime      *string `xml:"date_time,omitempty"`
	DateTimeEpoch *int    `xml:"date_time_epoch,omitempty"`
	Event         *string `xml:"event,omitempty"`
	Username      *string `xml:"username,omitempty"`
}

MobileDeviceHistoryAuditsAuditItem represents a mobile device history audits audit item.

func (MobileDeviceHistoryAuditsAuditItem) MarshalXML 

func (t MobileDeviceHistoryAuditsAuditItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryAuditsAuditItem root element name to the wire value declared by the spec (<audit>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryEbooks 

type MobileDeviceHistoryEbooks struct {
	XMLName   xml.Name
	ID        *int                                    `xml:"id,omitempty"`
	Failed    *[]MobileDeviceHistoryEbooksFailedItem  `xml:"failed,omitempty"`
	Installed *MobileDeviceHistoryEbooksInstalled     `xml:"installed,omitempty"`
	Pending   *[]MobileDeviceHistoryEbooksPendingItem `xml:"pending,omitempty"`
}

MobileDeviceHistoryEbooks represents a mobile device history ebooks.

func (MobileDeviceHistoryEbooks) MarshalXML 

func (t MobileDeviceHistoryEbooks) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryEbooks root element name to the wire value declared by the spec (<ebooks>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryEbooksFailedItem 

type MobileDeviceHistoryEbooksFailedItem struct {
	XMLName          xml.Name
	Author           *string `xml:"author,omitempty"`
	Kind             *string `xml:"kind,omitempty"`
	ManagementStatus *string `xml:"management_status,omitempty"`
	Title            *string `xml:"title,omitempty"`
	Version          *string `xml:"version,omitempty"`
}

MobileDeviceHistoryEbooksFailedItem represents a mobile device history ebooks failed item.

func (MobileDeviceHistoryEbooksFailedItem) MarshalXML 

func (t MobileDeviceHistoryEbooksFailedItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryEbooksFailedItem root element name to the wire value declared by the spec (<failed>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryEbooksInstalled 

type MobileDeviceHistoryEbooksInstalled struct {
	XMLName    xml.Name
	Ibookstore *[]MobileDeviceHistoryEbooksInstalledIbookstoreItem `xml:"ibookstore,omitempty"`
	Inhouse    *[]MobileDeviceHistoryEbooksInstalledInhouseItem    `xml:"inhouse,omitempty"`
}

MobileDeviceHistoryEbooksInstalled represents a mobile device history ebooks installed.

func (MobileDeviceHistoryEbooksInstalled) MarshalXML 

func (t MobileDeviceHistoryEbooksInstalled) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryEbooksInstalled root element name to the wire value declared by the spec (<installed>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryEbooksInstalledIbookstoreItem 

type MobileDeviceHistoryEbooksInstalledIbookstoreItem struct {
	XMLName          xml.Name
	Author           *string `xml:"author,omitempty"`
	Kind             *string `xml:"kind,omitempty"`
	ManagementStatus *string `xml:"management_status,omitempty"`
	Title            *string `xml:"title,omitempty"`
	Version          *string `xml:"version,omitempty"`
}

MobileDeviceHistoryEbooksInstalledIbookstoreItem represents a mobile device history ebooks installed ibookstore item.

func (MobileDeviceHistoryEbooksInstalledIbookstoreItem) MarshalXML 

func (t MobileDeviceHistoryEbooksInstalledIbookstoreItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryEbooksInstalledIbookstoreItem root element name to the wire value declared by the spec (<ibookstore>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryEbooksInstalledInhouseItem 

type MobileDeviceHistoryEbooksInstalledInhouseItem struct {
	XMLName          xml.Name
	Author           *string `xml:"author,omitempty"`
	Kind             *string `xml:"kind,omitempty"`
	ManagementStatus *string `xml:"management_status,omitempty"`
	Title            *string `xml:"title,omitempty"`
	Version          *string `xml:"version,omitempty"`
}

MobileDeviceHistoryEbooksInstalledInhouseItem represents a mobile device history ebooks installed inhouse item.

func (MobileDeviceHistoryEbooksInstalledInhouseItem) MarshalXML 

func (t MobileDeviceHistoryEbooksInstalledInhouseItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryEbooksInstalledInhouseItem root element name to the wire value declared by the spec (<inhouse>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryEbooksPendingItem 

type MobileDeviceHistoryEbooksPendingItem struct {
	XMLName          xml.Name
	Author           *string `xml:"author,omitempty"`
	Kind             *string `xml:"kind,omitempty"`
	ManagementStatus *string `xml:"management_status,omitempty"`
	Title            *string `xml:"title,omitempty"`
	Version          *string `xml:"version,omitempty"`
}

MobileDeviceHistoryEbooksPendingItem represents a mobile device history ebooks pending item.

func (MobileDeviceHistoryEbooksPendingItem) MarshalXML 

func (t MobileDeviceHistoryEbooksPendingItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryEbooksPendingItem root element name to the wire value declared by the spec (<pending>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryGeneral 

type MobileDeviceHistoryGeneral struct {
	XMLName    xml.Name
	ID         *int    `xml:"id,omitempty"`
	MacAddress *string `xml:"mac_address,omitempty"`
	// Name of the device.
	Name         *string `xml:"name,omitempty"`
	SerialNumber *string `xml:"serial_number,omitempty"`
	UDID         *string `xml:"udid,omitempty"`
}

MobileDeviceHistoryGeneral represents a mobile device history general.

func (MobileDeviceHistoryGeneral) MarshalXML 

func (t MobileDeviceHistoryGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryManagementCommands 

type MobileDeviceHistoryManagementCommands struct {
	XMLName   xml.Name
	ID        *int                                            `xml:"id,omitempty"`
	Completed *MobileDeviceHistoryManagementCommandsCompleted `xml:"completed,omitempty"`
	Failed    *MobileDeviceHistoryManagementCommandsFailed    `xml:"failed,omitempty"`
	Pending   *MobileDeviceHistoryManagementCommandsPending   `xml:"pending,omitempty"`
}

MobileDeviceHistoryManagementCommands represents a mobile device history management commands.

func (MobileDeviceHistoryManagementCommands) MarshalXML 

func (t MobileDeviceHistoryManagementCommands) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryManagementCommands root element name to the wire value declared by the spec (<management_commands>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryManagementCommandsCompleted 

type MobileDeviceHistoryManagementCommandsCompleted struct {
	XMLName xml.Name
	Command *[]MobileDeviceHistoryManagementCommandsCompletedCommandItem `xml:"command,omitempty"`
}

MobileDeviceHistoryManagementCommandsCompleted represents a mobile device history management commands completed.

func (MobileDeviceHistoryManagementCommandsCompleted) MarshalXML 

func (t MobileDeviceHistoryManagementCommandsCompleted) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryManagementCommandsCompleted root element name to the wire value declared by the spec (<completed>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryManagementCommandsCompletedCommandItem 

type MobileDeviceHistoryManagementCommandsCompletedCommandItem struct {
	XMLName                xml.Name
	DateTimeCompleted      *string `xml:"date_time_completed,omitempty"`
	DateTimeCompletedEpoch *int    `xml:"date_time_completed_epoch,omitempty"`
	Name                   *string `xml:"name,omitempty"`
}

MobileDeviceHistoryManagementCommandsCompletedCommandItem represents a mobile device history management commands completed command item.

func (MobileDeviceHistoryManagementCommandsCompletedCommandItem) MarshalXML 

func (t MobileDeviceHistoryManagementCommandsCompletedCommandItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryManagementCommandsCompletedCommandItem root element name to the wire value declared by the spec (<command>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryManagementCommandsFailed 

type MobileDeviceHistoryManagementCommandsFailed struct {
	XMLName xml.Name
	Command *[]MobileDeviceHistoryManagementCommandsFailedCommandItem `xml:"command,omitempty"`
}

MobileDeviceHistoryManagementCommandsFailed represents a mobile device history management commands failed.

func (MobileDeviceHistoryManagementCommandsFailed) MarshalXML 

func (t MobileDeviceHistoryManagementCommandsFailed) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryManagementCommandsFailed root element name to the wire value declared by the spec (<failed>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryManagementCommandsFailedCommandItem 

type MobileDeviceHistoryManagementCommandsFailedCommandItem struct {
	XMLName             xml.Name
	DateTimeFailed      *string `xml:"date_time_failed,omitempty"`
	DateTimeFailedEpoch *int    `xml:"date_time_failed_epoch,omitempty"`
	DateTimeIssued      *string `xml:"date_time_issued,omitempty"`
	DateTimeIssuedEpoch *string `xml:"date_time_issued_epoch,omitempty"`
	Error               *string `xml:"error,omitempty"`
	Name                *string `xml:"name,omitempty"`
}

MobileDeviceHistoryManagementCommandsFailedCommandItem represents a mobile device history management commands failed command item.

func (MobileDeviceHistoryManagementCommandsFailedCommandItem) MarshalXML 

func (t MobileDeviceHistoryManagementCommandsFailedCommandItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryManagementCommandsFailedCommandItem root element name to the wire value declared by the spec (<command>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryManagementCommandsPending 

type MobileDeviceHistoryManagementCommandsPending struct {
	XMLName xml.Name
	Command *[]MobileDeviceHistoryManagementCommandsPendingCommandItem `xml:"command,omitempty"`
}

MobileDeviceHistoryManagementCommandsPending represents a mobile device history management commands pending.

func (MobileDeviceHistoryManagementCommandsPending) MarshalXML 

func (t MobileDeviceHistoryManagementCommandsPending) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryManagementCommandsPending root element name to the wire value declared by the spec (<pending>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryManagementCommandsPendingCommandItem 

type MobileDeviceHistoryManagementCommandsPendingCommandItem struct {
	XMLName             xml.Name
	DateTimeFailed      *string `xml:"date_time_failed,omitempty"`
	DateTimeFailedEpoch *int    `xml:"date_time_failed_epoch,omitempty"`
	DateTimeIssued      *string `xml:"date_time_issued,omitempty"`
	DateTimeIssuedEpoch *string `xml:"date_time_issued_epoch,omitempty"`
	Name                *string `xml:"name,omitempty"`
}

MobileDeviceHistoryManagementCommandsPendingCommandItem represents a mobile device history management commands pending command item.

func (MobileDeviceHistoryManagementCommandsPendingCommandItem) MarshalXML 

func (t MobileDeviceHistoryManagementCommandsPendingCommandItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryManagementCommandsPendingCommandItem root element name to the wire value declared by the spec (<command>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryUserLocation 

type MobileDeviceHistoryUserLocation struct {
	XMLName  xml.Name
	Location *[]MobileDeviceHistoryUserLocationLocationItem `xml:"location,omitempty"`
}

MobileDeviceHistoryUserLocation represents a mobile device history user location.

func (MobileDeviceHistoryUserLocation) MarshalXML 

func (t MobileDeviceHistoryUserLocation) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryUserLocation root element name to the wire value declared by the spec (<user_location>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceHistoryUserLocationLocationItem 

type MobileDeviceHistoryUserLocationLocationItem struct {
	XMLName       xml.Name
	Building      *string `xml:"building,omitempty"`
	DateTime      *string `xml:"date_time,omitempty"`
	DateTimeEpoch *int    `xml:"date_time_epoch,omitempty"`
	Department    *string `xml:"department,omitempty"`
	EmailAddress  *string `xml:"email_address,omitempty"`
	FullName      *string `xml:"full_name,omitempty"`
	PhoneNumber   *string `xml:"phone_number,omitempty"`
	Position      *string `xml:"position,omitempty"`
	Room          *string `xml:"room,omitempty"`
	Username      *string `xml:"username,omitempty"`
}

MobileDeviceHistoryUserLocationLocationItem represents a mobile device history user location location item.

func (MobileDeviceHistoryUserLocationLocationItem) MarshalXML 

func (t MobileDeviceHistoryUserLocationLocationItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceHistoryUserLocationLocationItem root element name to the wire value declared by the spec (<location>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceInvitation 

type MobileDeviceInvitation struct {
	XMLName        xml.Name
	DateSent       *string                               `xml:"date_sent,omitempty"`
	DateSentEpoch  *BigInt                               `xml:"date_sent_epoch"`
	DateSentUtc    *string                               `xml:"date_sent_utc,omitempty"`
	EnrollIntoSite *MobileDeviceInvitationEnrollIntoSite `xml:"enroll_into_site,omitempty"`
	// Use 'Unlimited' to specify no expiration.
	ExpirationDate             *string     `xml:"expiration_date,omitempty"`
	ExpirationDateEpoch        *BigInt     `xml:"expiration_date_epoch"`
	ExpirationDateUtc          *string     `xml:"expiration_date_utc,omitempty"`
	ID                         *int        `xml:"id,omitempty"`
	Invitation                 *BigInt     `xml:"invitation"`
	InvitationType             *string     `xml:"invitation_type,omitempty"`
	KeepExistingSiteMembership *bool       `xml:"keep_existing_site_membership,omitempty"`
	LastAction                 *string     `xml:"last_action,omitempty"`
	LoginRequired              *bool       `xml:"login_required,omitempty"`
	Message                    *string     `xml:"message,omitempty"`
	MultipleUsesAllowed        *bool       `xml:"multiple_uses_allowed,omitempty"`
	ReplyTo                    *string     `xml:"reply_to,omitempty"`
	SentFrom                   *string     `xml:"sent_from,omitempty"`
	SentTo                     *string     `xml:"sent_to,omitempty"`
	Site                       *SiteObject `xml:"site,omitempty"`
	Subject                    *string     `xml:"subject,omitempty"`
	TargetIos                  *string     `xml:"target_ios,omitempty"`
	Username                   *string     `xml:"username,omitempty"`
}

MobileDeviceInvitation represents a mobile device invitation.

func (MobileDeviceInvitation) MarshalXML 

func (t MobileDeviceInvitation) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceInvitation root element name to the wire value declared by the spec (<mobile_device_invitation>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceInvitationEnrollIntoSite 

type MobileDeviceInvitationEnrollIntoSite struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
}

MobileDeviceInvitationEnrollIntoSite represents a mobile device invitation enroll into site.

func (MobileDeviceInvitationEnrollIntoSite) MarshalXML 

func (t MobileDeviceInvitationEnrollIntoSite) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceInvitationEnrollIntoSite root element name to the wire value declared by the spec (<enroll_into_site>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceInvitationPost 

type MobileDeviceInvitationPost struct {
	XMLName           xml.Name
	AllowMultipleUses *bool                                     `xml:"allow_multiple_uses,omitempty"`
	DateSent          *string                                   `xml:"date_sent,omitempty"`
	DateSentEpoch     *BigInt                                   `xml:"date_sent_epoch"`
	DateSentUtc       *string                                   `xml:"date_sent_utc,omitempty"`
	EnrollIntoSite    *MobileDeviceInvitationPostEnrollIntoSite `xml:"enroll_into_site,omitempty"`
	// Use 'Unlimited' to specify no expiration.
	ExpirationDate             *string     `xml:"expiration_date,omitempty"`
	ExpirationDateEpoch        *BigInt     `xml:"expiration_date_epoch"`
	ExpirationDateUtc          *string     `xml:"expiration_date_utc,omitempty"`
	ID                         *int        `xml:"id,omitempty"`
	Invitation                 *BigInt     `xml:"invitation"`
	InvitationType             *string     `xml:"invitation_type,omitempty"`
	KeepExistingSiteMembership *bool       `xml:"keep_existing_site_membership,omitempty"`
	LastAction                 *string     `xml:"last_action,omitempty"`
	LoginRequired              *bool       `xml:"login_required,omitempty"`
	Message                    *string     `xml:"message,omitempty"`
	MultipleUsesAllowed        *bool       `xml:"multiple_uses_allowed,omitempty"`
	ReplyTo                    *string     `xml:"reply_to,omitempty"`
	RequireLogin               *bool       `xml:"require_login,omitempty"`
	SentFrom                   *string     `xml:"sent_from,omitempty"`
	SentTo                     *string     `xml:"sent_to,omitempty"`
	Site                       *SiteObject `xml:"site,omitempty"`
	Subject                    *string     `xml:"subject,omitempty"`
	TargetIos                  *string     `xml:"target_ios,omitempty"`
	Username                   *string     `xml:"username,omitempty"`
}

MobileDeviceInvitationPost represents a mobile device invitation post.

func (MobileDeviceInvitationPost) MarshalXML 

func (t MobileDeviceInvitationPost) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceInvitationPost root element name to the wire value declared by the spec (<mobile_device_invitation>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceInvitationPostEnrollIntoSite 

type MobileDeviceInvitationPostEnrollIntoSite struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
}

MobileDeviceInvitationPostEnrollIntoSite represents a mobile device invitation post enroll into site.

func (MobileDeviceInvitationPostEnrollIntoSite) MarshalXML 

func (t MobileDeviceInvitationPostEnrollIntoSite) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceInvitationPostEnrollIntoSite root element name to the wire value declared by the spec (<enroll_into_site>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceInvitations 

type MobileDeviceInvitations struct {
	XMLName                 xml.Name
	Size                    *Size                                               `xml:"size,omitempty"`
	MobileDeviceInvitations []MobileDeviceInvitationsItemMobileDeviceInvitation `xml:"mobile_device_invitation"`
}

MobileDeviceInvitations wraps a Jamf Classic list response with a flat slice of MobileDeviceInvitationsItemMobileDeviceInvitation.

func (MobileDeviceInvitations) MarshalXML 

func (t MobileDeviceInvitations) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceInvitations root element name to the wire value declared by the spec (<mobile_device_invitations>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceInvitationsItem 

type MobileDeviceInvitationsItem struct {
	XMLName                xml.Name
	ID                     *int                                               `xml:"id,omitempty"`
	MobileDeviceInvitation *MobileDeviceInvitationsItemMobileDeviceInvitation `xml:"mobile_device_invitation,omitempty"`
	Size                   *Size                                              `xml:"size,omitempty"`
}

MobileDeviceInvitationsItem represents a mobile device invitations item.

func (MobileDeviceInvitationsItem) MarshalXML 

func (t MobileDeviceInvitationsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceInvitationsItem root element name to the wire value declared by the spec (<mobile_device_invitation>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceInvitationsItemMobileDeviceInvitation 

type MobileDeviceInvitationsItemMobileDeviceInvitation struct {
	XMLName             xml.Name
	ExpirationDate      *string `xml:"expiration_date,omitempty"`
	ExpirationDateEpoch *BigInt `xml:"expiration_date_epoch"`
	ExpirationDateUtc   *string `xml:"expiration_date_utc,omitempty"`
	ID                  *int    `xml:"id,omitempty"`
	Invitation          *BigInt `xml:"invitation"`
	InvitationType      *string `xml:"invitation_type,omitempty"`
	LastAction          *string `xml:"last_action,omitempty"`
}

MobileDeviceInvitationsItemMobileDeviceInvitation represents a mobile device invitations item mobile device invitation.

func (MobileDeviceInvitationsItemMobileDeviceInvitation) MarshalXML 

func (t MobileDeviceInvitationsItemMobileDeviceInvitation) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceInvitationsItemMobileDeviceInvitation root element name to the wire value declared by the spec (<mobile_device_invitation>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceMobileDeviceGroups 

type MobileDeviceMobileDeviceGroups struct {
	XMLName           xml.Name
	MobileDeviceGroup *[]IDName `xml:"mobile_device_group,omitempty"`
	Size              *Size     `xml:"size,omitempty"`
}

MobileDeviceMobileDeviceGroups represents a mobile device mobile device groups.

func (MobileDeviceMobileDeviceGroups) MarshalXML 

func (t MobileDeviceMobileDeviceGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceMobileDeviceGroups root element name to the wire value declared by the spec (<mobile_device_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceNetwork 

type MobileDeviceNetwork struct {
	XMLName                  xml.Name
	CarrierSettingsVersion   *string `xml:"carrier_settings_version,omitempty"`
	CellularTechnology       *string `xml:"cellular_technology,omitempty"`
	CurrentCarrierNetwork    *string `xml:"current_carrier_network,omitempty"`
	CurrentMobileCountryCode *string `xml:"current_mobile_country_code,omitempty"`
	CurrentMobileNetworkCode *string `xml:"current_mobile_network_code,omitempty"`
	DataRoamingEnabled       *bool   `xml:"data_roaming_enabled,omitempty"`
	HomeCarrierNetwork       *string `xml:"home_carrier_network,omitempty"`
	HomeMobileCountryCode    *string `xml:"home_mobile_country_code,omitempty"`
	HomeMobileNetworkCode    *string `xml:"home_mobile_network_code,omitempty"`
	Iccid                    *string `xml:"iccid,omitempty"`
	Imei                     *string `xml:"imei,omitempty"`
	PhoneNumber              *string `xml:"phone_number,omitempty"`
	VoiceRoamingEnabled      *string `xml:"voice_roaming_enabled,omitempty"`
}

MobileDeviceNetwork represents a mobile device network.

func (MobileDeviceNetwork) MarshalXML 

func (t MobileDeviceNetwork) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceNetwork root element name to the wire value declared by the spec (<network>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDevicePost 

type MobileDevicePost struct {
	XMLName               xml.Name
	ID                    *int                                   `xml:"id,omitempty"`
	Applications          *MobileDevicePostApplications          `xml:"applications,omitempty"`
	Certificates          *MobileDevicePostCertificates          `xml:"certificates,omitempty"`
	ConfigurationProfiles *MobileDevicePostConfigurationProfiles `xml:"configuration_profiles,omitempty"`
	ExtensionAttributes   *[]MobileDeviceExtensionAttributesItem `xml:"extension_attributes,omitempty"`
	General               *MobileDevicePostGeneral               `xml:"general,omitempty"`
	Location              *Location                              `xml:"location,omitempty"`
	MobileDeviceGroups    *MobileDevicePostMobileDeviceGroups    `xml:"mobile_device_groups,omitempty"`
	Network               *MobileDevicePostNetwork               `xml:"network,omitempty"`
	ProvisioningProfiles  *MobileDevicePostProvisioningProfiles  `xml:"provisioning_profiles,omitempty"`
	Purchasing            *Purchasing                            `xml:"purchasing,omitempty"`
	SecurityObject        *MobileDevicePostSecurityObject        `xml:"security_object,omitempty"`
}

MobileDevicePost represents a mobile device post.

func (MobileDevicePost) MarshalXML 

func (t MobileDevicePost) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDevicePost root element name to the wire value declared by the spec (<mobile_device>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDevicePostApplications 

type MobileDevicePostApplications struct {
	XMLName     xml.Name
	Application *[]MobileDevicePostApplicationsApplicationItem `xml:"application,omitempty"`
	Size        *Size                                          `xml:"size,omitempty"`
}

MobileDevicePostApplications represents a mobile device post applications.

func (MobileDevicePostApplications) MarshalXML 

func (t MobileDevicePostApplications) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDevicePostApplications root element name to the wire value declared by the spec (<applications>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDevicePostApplicationsApplicationItem 

type MobileDevicePostApplicationsApplicationItem struct {
	XMLName            xml.Name
	ApplicationName    *string `xml:"application_name,omitempty"`
	ApplicationVersion *string `xml:"application_version,omitempty"`
	Identifier         *string `xml:"identifier,omitempty"`
}

MobileDevicePostApplicationsApplicationItem represents a mobile device post applications application item.

func (MobileDevicePostApplicationsApplicationItem) MarshalXML 

func (t MobileDevicePostApplicationsApplicationItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDevicePostApplicationsApplicationItem root element name to the wire value declared by the spec (<application>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDevicePostCertificates 

type MobileDevicePostCertificates struct {
	XMLName     xml.Name
	Certificate *[]MobileDevicePostCertificatesCertificateItem `xml:"certificate,omitempty"`
	Size        *Size                                          `xml:"size,omitempty"`
}

MobileDevicePostCertificates represents a mobile device post certificates.

func (MobileDevicePostCertificates) MarshalXML 

func (t MobileDevicePostCertificates) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDevicePostCertificates root element name to the wire value declared by the spec (<certificates>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDevicePostCertificatesCertificateItem 

type MobileDevicePostCertificatesCertificateItem struct {
	XMLName    xml.Name
	CommonName *string `xml:"common_name,omitempty"`
	Identity   *bool   `xml:"identity,omitempty"`
}

MobileDevicePostCertificatesCertificateItem represents a mobile device post certificates certificate item.

func (MobileDevicePostCertificatesCertificateItem) MarshalXML 

func (t MobileDevicePostCertificatesCertificateItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDevicePostCertificatesCertificateItem root element name to the wire value declared by the spec (<certificate>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDevicePostConfigurationProfiles 

type MobileDevicePostConfigurationProfiles struct {
	XMLName              xml.Name
	ConfigurationProfile *[]MobileDevicePostConfigurationProfilesConfigurationProfileItem `xml:"configuration_profile,omitempty"`
	Size                 *Size                                                            `xml:"size,omitempty"`
}

MobileDevicePostConfigurationProfiles represents a mobile device post configuration profiles.

func (MobileDevicePostConfigurationProfiles) MarshalXML 

func (t MobileDevicePostConfigurationProfiles) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDevicePostConfigurationProfiles root element name to the wire value declared by the spec (<configuration_profiles>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDevicePostConfigurationProfilesConfigurationProfileItem 

type MobileDevicePostConfigurationProfilesConfigurationProfileItem struct {
	XMLName     xml.Name
	DisplayName *string `xml:"display_name,omitempty"`
	Identifier  *string `xml:"identifier,omitempty"`
	UUID        *string `xml:"uuid,omitempty"`
	Version     *int    `xml:"version,omitempty"`
}

MobileDevicePostConfigurationProfilesConfigurationProfileItem represents a mobile device post configuration profiles configuration profile item.

func (MobileDevicePostConfigurationProfilesConfigurationProfileItem) MarshalXML 

func (t MobileDevicePostConfigurationProfilesConfigurationProfileItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDevicePostConfigurationProfilesConfigurationProfileItem root element name to the wire value declared by the spec (<configuration_profile>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDevicePostGeneral 

type MobileDevicePostGeneral struct {
	XMLName                            xml.Name
	AssetTag                           *string `xml:"asset_tag,omitempty"`
	Available                          *int    `xml:"available,omitempty"`
	AvailableMb                        *int    `xml:"available_mb,omitempty"`
	BatteryLevel                       *int    `xml:"battery_level,omitempty"`
	BleCapable                         *bool   `xml:"ble_capable,omitempty"`
	BluetoothMacAddress                *string `xml:"bluetooth_mac_address,omitempty"`
	Capacity                           *int    `xml:"capacity,omitempty"`
	CapacityMb                         *int    `xml:"capacity_mb,omitempty"`
	CloudBackupEnabled                 *bool   `xml:"cloud_backup_enabled,omitempty"`
	DeviceLocatorServiceEnabled        *bool   `xml:"device_locator_service_enabled,omitempty"`
	DeviceName                         *string `xml:"device_name,omitempty"`
	DeviceOwnershipLevel               *string `xml:"device_ownership_level,omitempty"`
	DisplayName                        *string `xml:"display_name,omitempty"`
	DoNotDisturbEnabled                *bool   `xml:"do_not_disturb_enabled,omitempty"`
	ExchangeActivesyncDeviceIdentifier *string `xml:"exchange_activesync_device_identifier,omitempty"`
	ID                                 *int    `xml:"id,omitempty"`
	InitialEntryDateEpoch              *int    `xml:"initial_entry_date_epoch,omitempty"`
	InitialEntryDateUtc                *string `xml:"initial_entry_date_utc,omitempty"`
	IPAddress                          *string `xml:"ip_address,omitempty"`
	ItunesStoreAccountIsActive         *bool   `xml:"itunes_store_account_is_active,omitempty"`
	LastBackupTimeEpoch                *int    `xml:"last_backup_time_epoch,omitempty"`
	LastBackupTimeUtc                  *string `xml:"last_backup_time_utc,omitempty"`
	LastCloudBackupDateEpoch           *int    `xml:"last_cloud_backup_date_epoch,omitempty"`
	LastCloudBackupDateUtc             *string `xml:"last_cloud_backup_date_utc,omitempty"`
	LastEnrollmentEpoch                *int    `xml:"last_enrollment_epoch,omitempty"`
	LastEnrollmentUtc                  *string `xml:"last_enrollment_utc,omitempty"`
	LastInventoryUpdate                *string `xml:"last_inventory_update,omitempty"`
	LastInventoryUpdateEpoch           *int    `xml:"last_inventory_update_epoch,omitempty"`
	LastInventoryUpdateUtc             *string `xml:"last_inventory_update_utc,omitempty"`
	LocationServicesEnabled            *bool   `xml:"location_services_enabled,omitempty"`
	Managed                            *bool   `xml:"managed,omitempty"`
	Model                              *string `xml:"model,omitempty"`
	ModelDisplay                       *string `xml:"model_display,omitempty"`
	ModelIdentifier                    *string `xml:"model_identifier,omitempty"`
	ModelNumber                        *string `xml:"model_number,omitempty"`
	ModemFirmware                      *string `xml:"modem_firmware,omitempty"`
	Name                               *string `xml:"name,omitempty"`
	OsBuild                            *string `xml:"os_build,omitempty"`
	OsType                             *string `xml:"os_type,omitempty"`
	OsVersion                          *string `xml:"os_version,omitempty"`
	PercentageUsed                     *int    `xml:"percentage_used,omitempty"`
	PhoneNumber                        *string `xml:"phone_number,omitempty"`
	SerialNumber                       *string `xml:"serial_number,omitempty"`
	Shared                             *string `xml:"shared,omitempty"`
	Supervised                         *bool   `xml:"supervised,omitempty"`
	Tethered                           *string `xml:"tethered,omitempty"`
	UDID                               *string `xml:"udid,omitempty"`
	WifiMacAddress                     *string `xml:"wifi_mac_address,omitempty"`
}

MobileDevicePostGeneral represents a mobile device post general.

func (MobileDevicePostGeneral) MarshalXML 

func (t MobileDevicePostGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDevicePostGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDevicePostMobileDeviceGroups 

type MobileDevicePostMobileDeviceGroups struct {
	XMLName           xml.Name
	MobileDeviceGroup *[]IDName `xml:"mobile_device_group,omitempty"`
	Size              *Size     `xml:"size,omitempty"`
}

MobileDevicePostMobileDeviceGroups represents a mobile device post mobile device groups.

func (MobileDevicePostMobileDeviceGroups) MarshalXML 

func (t MobileDevicePostMobileDeviceGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDevicePostMobileDeviceGroups root element name to the wire value declared by the spec (<mobile_device_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDevicePostNetwork 

type MobileDevicePostNetwork struct {
	XMLName                  xml.Name
	CarrierSettingsVersion   *string `xml:"carrier_settings_version,omitempty"`
	CellularTechnology       *string `xml:"cellular_technology,omitempty"`
	CurrentCarrierNetwork    *string `xml:"current_carrier_network,omitempty"`
	CurrentMobileCountryCode *string `xml:"current_mobile_country_code,omitempty"`
	CurrentMobileNetworkCode *string `xml:"current_mobile_network_code,omitempty"`
	DataRoamingEnabled       *bool   `xml:"data_roaming_enabled,omitempty"`
	HomeCarrierNetwork       *string `xml:"home_carrier_network,omitempty"`
	HomeMobileCountryCode    *string `xml:"home_mobile_country_code,omitempty"`
	HomeMobileNetworkCode    *string `xml:"home_mobile_network_code,omitempty"`
	Iccid                    *string `xml:"iccid,omitempty"`
	Imei                     *string `xml:"imei,omitempty"`
	PhoneNumber              *string `xml:"phone_number,omitempty"`
	VoiceRoamingEnabled      *string `xml:"voice_roaming_enabled,omitempty"`
}

MobileDevicePostNetwork represents a mobile device post network.

func (MobileDevicePostNetwork) MarshalXML 

func (t MobileDevicePostNetwork) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDevicePostNetwork root element name to the wire value declared by the spec (<network>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDevicePostProvisioningProfiles 

type MobileDevicePostProvisioningProfiles struct {
	XMLName                         xml.Name
	MobileDeviceProvisioningProfile *[]MobileDevicePostProvisioningProfilesMobileDeviceProvisioningProfileItem `xml:"mobile_device_provisioning_profile,omitempty"`
	Size                            *Size                                                                      `xml:"size,omitempty"`
}

MobileDevicePostProvisioningProfiles represents a mobile device post provisioning profiles.

func (MobileDevicePostProvisioningProfiles) MarshalXML 

func (t MobileDevicePostProvisioningProfiles) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDevicePostProvisioningProfiles root element name to the wire value declared by the spec (<provisioning_profiles>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDevicePostProvisioningProfilesMobileDeviceProvisioningProfileItem 

type MobileDevicePostProvisioningProfilesMobileDeviceProvisioningProfileItem struct {
	XMLName             xml.Name
	ID                  *int    `xml:"id,omitempty"`
	DisplayName         *string `xml:"display_name,omitempty"`
	ExpirationDate      *string `xml:"expiration_date,omitempty"`
	ExpirationDateEpoch *BigInt `xml:"expiration_date_epoch"`
	ExpirationDateUtc   *string `xml:"expiration_date_utc,omitempty"`
	UUID                *string `xml:"uuid,omitempty"`
}

MobileDevicePostProvisioningProfilesMobileDeviceProvisioningProfileItem represents a mobile device post provisioning profiles mobile device provisioning profile item.

func (MobileDevicePostProvisioningProfilesMobileDeviceProvisioningProfileItem) MarshalXML 

func (t MobileDevicePostProvisioningProfilesMobileDeviceProvisioningProfileItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDevicePostProvisioningProfilesMobileDeviceProvisioningProfileItem root element name to the wire value declared by the spec (<mobile_device_provisioning_profile>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDevicePostSecurityObject 

type MobileDevicePostSecurityObject struct {
	ActivationLockEnabled           *bool   `xml:"activation_lock_enabled,omitempty"`
	BlockLevelEncryptionCapable     *bool   `xml:"block_level_encryption_capable,omitempty"`
	DataProtection                  *bool   `xml:"data_protection,omitempty"`
	FileLevelEncryptionCapable      *bool   `xml:"file_level_encryption_capable,omitempty"`
	HardwareEncryption              *string `xml:"hardware_encryption,omitempty"`
	JailbreakDetected               *string `xml:"jailbreak_detected,omitempty"`
	LostLocationAltitude            *string `xml:"lost_location_altitude,omitempty"`
	LostLocationCourse              *string `xml:"lost_location_course,omitempty"`
	LostLocationEpoch               *int    `xml:"lost_location_epoch,omitempty"`
	LostLocationHorizontalAccuracy  *string `xml:"lost_location_horizontal_accuracy,omitempty"`
	LostLocationLatitude            *string `xml:"lost_location_latitude,omitempty"`
	LostLocationLongitude           *string `xml:"lost_location_longitude,omitempty"`
	LostLocationSpeed               *string `xml:"lost_location_speed,omitempty"`
	LostLocationUtc                 *string `xml:"lost_location_utc,omitempty"`
	LostLocationVerticalAccuracy    *string `xml:"lost_location_vertical_accuracy,omitempty"`
	LostModeEnableIssuedEpoch       *int    `xml:"lost_mode_enable_issued_epoch,omitempty"`
	LostModeEnableIssuedUtc         *string `xml:"lost_mode_enable_issued_utc,omitempty"`
	LostModeEnabled                 *string `xml:"lost_mode_enabled,omitempty"`
	LostModeEnforced                *bool   `xml:"lost_mode_enforced,omitempty"`
	LostModeFootnote                *string `xml:"lost_mode_footnote,omitempty"`
	LostModeMessage                 *string `xml:"lost_mode_message,omitempty"`
	LostModePhone                   *string `xml:"lost_mode_phone,omitempty"`
	PasscodeCompliant               *bool   `xml:"passcode_compliant,omitempty"`
	PasscodeCompliantWithProfile    *bool   `xml:"passcode_compliant_with_profile,omitempty"`
	PasscodeLockGracePeriodEnforced *string `xml:"passcode_lock_grace_period_enforced,omitempty"`
	PasscodePresent                 *bool   `xml:"passcode_present,omitempty"`
}

MobileDevicePostSecurityObject represents a mobile device post security object.

type MobileDeviceProvisioningProfile 

type MobileDeviceProvisioningProfile struct {
	XMLName xml.Name
	ID      *int                                    `xml:"id,omitempty"`
	General *MobileDeviceProvisioningProfileGeneral `xml:"general,omitempty"`
}

MobileDeviceProvisioningProfile represents a mobile device provisioning profile.

func (MobileDeviceProvisioningProfile) MarshalXML 

func (t MobileDeviceProvisioningProfile) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceProvisioningProfile root element name to the wire value declared by the spec (<mobile_device_provisioning_profile>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceProvisioningProfileGeneral 

type MobileDeviceProvisioningProfileGeneral struct {
	XMLName             xml.Name
	CreationDateEpoch   *int                                           `xml:"creation_date_epoch,omitempty"`
	CreationDateUtc     *string                                        `xml:"creation_date_utc,omitempty"`
	DisplayName         *string                                        `xml:"display_name,omitempty"`
	ExpirationDateEpoch *BigInt                                        `xml:"expiration_date_epoch"`
	ExpirationDateUtc   *string                                        `xml:"expiration_date_utc,omitempty"`
	ID                  *int                                           `xml:"id,omitempty"`
	Name                *string                                        `xml:"name,omitempty"`
	Profile             *MobileDeviceProvisioningProfileGeneralProfile `xml:"profile,omitempty"`
	UUID                *string                                        `xml:"uuid,omitempty"`
}

MobileDeviceProvisioningProfileGeneral represents a mobile device provisioning profile general.

func (MobileDeviceProvisioningProfileGeneral) MarshalXML 

func (t MobileDeviceProvisioningProfileGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceProvisioningProfileGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceProvisioningProfileGeneralProfile 

type MobileDeviceProvisioningProfileGeneralProfile struct {
	XMLName xml.Name
	Data    *string `xml:"data,omitempty"`
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
	URI     *string `xml:"uri,omitempty"`
}

MobileDeviceProvisioningProfileGeneralProfile represents a mobile device provisioning profile general profile.

func (MobileDeviceProvisioningProfileGeneralProfile) MarshalXML 

func (t MobileDeviceProvisioningProfileGeneralProfile) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceProvisioningProfileGeneralProfile root element name to the wire value declared by the spec (<profile>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceProvisioningProfiles 

type MobileDeviceProvisioningProfiles struct {
	XMLName                          xml.Name
	Size                             *Size                                                                 `xml:"size,omitempty"`
	MobileDeviceProvisioningProfiles []MobileDeviceProvisioningProfilesItemMobileDeviceProvisioningProfile `xml:"mobile_device_provisioning_profile"`
}

MobileDeviceProvisioningProfiles wraps a Jamf Classic list response with a flat slice of MobileDeviceProvisioningProfilesItemMobileDeviceProvisioningProfile.

func (MobileDeviceProvisioningProfiles) MarshalXML 

func (t MobileDeviceProvisioningProfiles) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceProvisioningProfiles root element name to the wire value declared by the spec (<mobile_device_provisioning_profiles>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceProvisioningProfiles2 

type MobileDeviceProvisioningProfiles2 struct {
	XMLName                         xml.Name
	MobileDeviceProvisioningProfile *[]MobileDeviceProvisioningProfiles2MobileDeviceProvisioningProfileItem `xml:"mobile_device_provisioning_profile,omitempty"`
	Size                            *Size                                                                   `xml:"size,omitempty"`
}

MobileDeviceProvisioningProfiles2 represents a mobile device provisioning profiles2.

func (MobileDeviceProvisioningProfiles2) MarshalXML 

func (t MobileDeviceProvisioningProfiles2) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceProvisioningProfiles2 root element name to the wire value declared by the spec (<provisioning_profiles>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceProvisioningProfiles2MobileDeviceProvisioningProfileItem 

type MobileDeviceProvisioningProfiles2MobileDeviceProvisioningProfileItem struct {
	XMLName             xml.Name
	ID                  *int    `xml:"id,omitempty"`
	DisplayName         *string `xml:"display_name,omitempty"`
	ExpirationDate      *string `xml:"expiration_date,omitempty"`
	ExpirationDateEpoch *BigInt `xml:"expiration_date_epoch"`
	ExpirationDateUtc   *string `xml:"expiration_date_utc,omitempty"`
	UUID                *string `xml:"uuid,omitempty"`
}

MobileDeviceProvisioningProfiles2MobileDeviceProvisioningProfileItem represents a mobile device provisioning profiles2 mobile device provisioning profile item.

func (MobileDeviceProvisioningProfiles2MobileDeviceProvisioningProfileItem) MarshalXML 

func (t MobileDeviceProvisioningProfiles2MobileDeviceProvisioningProfileItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceProvisioningProfiles2MobileDeviceProvisioningProfileItem root element name to the wire value declared by the spec (<mobile_device_provisioning_profile>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceProvisioningProfilesItem 

type MobileDeviceProvisioningProfilesItem struct {
	XMLName                         xml.Name
	ID                              *int                                                                 `xml:"id,omitempty"`
	MobileDeviceProvisioningProfile *MobileDeviceProvisioningProfilesItemMobileDeviceProvisioningProfile `xml:"mobile_device_provisioning_profile,omitempty"`
	Size                            *Size                                                                `xml:"size,omitempty"`
}

MobileDeviceProvisioningProfilesItem represents a mobile device provisioning profiles item.

func (MobileDeviceProvisioningProfilesItem) MarshalXML 

func (t MobileDeviceProvisioningProfilesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceProvisioningProfilesItem root element name to the wire value declared by the spec (<mobile_device_provisioning_profile>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceProvisioningProfilesItemMobileDeviceProvisioningProfile 

type MobileDeviceProvisioningProfilesItemMobileDeviceProvisioningProfile struct {
	XMLName     xml.Name
	DisplayName *string `xml:"display_name,omitempty"`
	ID          *int    `xml:"id,omitempty"`
	Name        *string `xml:"name,omitempty"`
	UUID        *string `xml:"uuid,omitempty"`
}

MobileDeviceProvisioningProfilesItemMobileDeviceProvisioningProfile represents a mobile device provisioning profiles item mobile device provisioning profile.

func (MobileDeviceProvisioningProfilesItemMobileDeviceProvisioningProfile) MarshalXML 

func (t MobileDeviceProvisioningProfilesItemMobileDeviceProvisioningProfile) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDeviceProvisioningProfilesItemMobileDeviceProvisioningProfile root element name to the wire value declared by the spec (<mobile_device_provisioning_profile>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDeviceSecurityObject 

type MobileDeviceSecurityObject struct {
	ActivationLockEnabled           *bool   `xml:"activation_lock_enabled,omitempty"`
	BlockLevelEncryptionCapable     *bool   `xml:"block_level_encryption_capable,omitempty"`
	DataProtection                  *bool   `xml:"data_protection,omitempty"`
	FileLevelEncryptionCapable      *bool   `xml:"file_level_encryption_capable,omitempty"`
	HardwareEncryption              *string `xml:"hardware_encryption,omitempty"`
	JailbreakDetected               *string `xml:"jailbreak_detected,omitempty"`
	LostLocationAltitude            *string `xml:"lost_location_altitude,omitempty"`
	LostLocationCourse              *string `xml:"lost_location_course,omitempty"`
	LostLocationEpoch               *int    `xml:"lost_location_epoch,omitempty"`
	LostLocationHorizontalAccuracy  *string `xml:"lost_location_horizontal_accuracy,omitempty"`
	LostLocationLatitude            *string `xml:"lost_location_latitude,omitempty"`
	LostLocationLongitude           *string `xml:"lost_location_longitude,omitempty"`
	LostLocationSpeed               *string `xml:"lost_location_speed,omitempty"`
	LostLocationUtc                 *string `xml:"lost_location_utc,omitempty"`
	LostLocationVerticalAccuracy    *string `xml:"lost_location_vertical_accuracy,omitempty"`
	LostModeEnableIssuedEpoch       *int    `xml:"lost_mode_enable_issued_epoch,omitempty"`
	LostModeEnableIssuedUtc         *string `xml:"lost_mode_enable_issued_utc,omitempty"`
	LostModeEnabled                 *string `xml:"lost_mode_enabled,omitempty"`
	LostModeEnforced                *bool   `xml:"lost_mode_enforced,omitempty"`
	LostModeFootnote                *string `xml:"lost_mode_footnote,omitempty"`
	LostModeMessage                 *string `xml:"lost_mode_message,omitempty"`
	LostModePhone                   *string `xml:"lost_mode_phone,omitempty"`
	PasscodeCompliant               *bool   `xml:"passcode_compliant,omitempty"`
	PasscodeCompliantWithProfile    *bool   `xml:"passcode_compliant_with_profile,omitempty"`
	PasscodeLockGracePeriodEnforced *string `xml:"passcode_lock_grace_period_enforced,omitempty"`
	PasscodePresent                 *bool   `xml:"passcode_present,omitempty"`
}

MobileDeviceSecurityObject represents a mobile device security object.

type MobileDevices 

type MobileDevices struct {
	XMLName       xml.Name
	MobileDevices []MobileDevicesItemMobileDevice `xml:"mobile_device"`
}

MobileDevices wraps a Jamf Classic list response with a flat slice of MobileDevicesItemMobileDevice.

func (MobileDevices) MarshalXML 

func (t MobileDevices) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDevices root element name to the wire value declared by the spec (<mobile_devices>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDevicesItem 

type MobileDevicesItem struct {
	XMLName      xml.Name
	ID           *int                           `xml:"id,omitempty"`
	MobileDevice *MobileDevicesItemMobileDevice `xml:"mobile_device,omitempty"`
}

MobileDevicesItem represents a mobile devices item.

func (MobileDevicesItem) MarshalXML 

func (t MobileDevicesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDevicesItem root element name to the wire value declared by the spec (<mobile_device>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type MobileDevicesItemMobileDevice 

type MobileDevicesItemMobileDevice struct {
	XMLName         xml.Name
	DeviceName      *string `xml:"device_name,omitempty"`
	ID              *int    `xml:"id,omitempty"`
	Managed         *bool   `xml:"managed,omitempty"`
	Model           *string `xml:"model,omitempty"`
	ModelDisplay    *string `xml:"model_display,omitempty"`
	ModelIdentifier *string `xml:"model_identifier,omitempty"`
	Name            *string `xml:"name,omitempty"`
	PhoneNumber     *string `xml:"phone_number,omitempty"`
	SerialNumber    *string `xml:"serial_number,omitempty"`
	Supervised      *bool   `xml:"supervised,omitempty"`
	UDID            *string `xml:"udid,omitempty"`
	Username        *string `xml:"username,omitempty"`
	WifiMacAddress  *string `xml:"wifi_mac_address,omitempty"`
}

MobileDevicesItemMobileDevice represents a mobile devices item mobile device.

func (MobileDevicesItemMobileDevice) MarshalXML 

func (t MobileDevicesItemMobileDevice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the MobileDevicesItemMobileDevice root element name to the wire value declared by the spec (<mobile_device>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type NetworkSegment 

type NetworkSegment struct {
	XMLName            xml.Name
	Building           *string `xml:"building,omitempty"`
	Department         *string `xml:"department,omitempty"`
	DistributionPoint  *string `xml:"distribution_point,omitempty"`
	DistributionServer *string `xml:"distribution_server,omitempty"`
	EndingAddress      *string `xml:"ending_address,omitempty"`
	ID                 *int    `xml:"id,omitempty"`
	// Name of the network segment.
	Name                *string `xml:"name,omitempty"`
	OverrideBuildings   *bool   `xml:"override_buildings,omitempty"`
	OverrideDepartments *bool   `xml:"override_departments,omitempty"`
	StartingAddress     *string `xml:"starting_address,omitempty"`
	SwuServer           *string `xml:"swu_server,omitempty"`
	URL                 *string `xml:"url,omitempty"`
}

NetworkSegment represents a network segment.

func (NetworkSegment) MarshalXML 

func (t NetworkSegment) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the NetworkSegment root element name to the wire value declared by the spec (<network_segment>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type NetworkSegmentPost 

type NetworkSegmentPost struct {
	XMLName            xml.Name
	Building           *string `xml:"building,omitempty"`
	Department         *string `xml:"department,omitempty"`
	DistributionPoint  *string `xml:"distribution_point,omitempty"`
	DistributionServer *string `xml:"distribution_server,omitempty"`
	EndingAddress      *string `xml:"ending_address,omitempty"`
	ID                 *int    `xml:"id,omitempty"`
	// Name of the network segment.
	Name                *string `xml:"name,omitempty"`
	OverrideBuildings   *bool   `xml:"override_buildings,omitempty"`
	OverrideDepartments *bool   `xml:"override_departments,omitempty"`
	StartingAddress     *string `xml:"starting_address,omitempty"`
	SwuServer           *string `xml:"swu_server,omitempty"`
	URL                 *string `xml:"url,omitempty"`
}

NetworkSegmentPost represents a network segment post.

func (NetworkSegmentPost) MarshalXML 

func (t NetworkSegmentPost) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the NetworkSegmentPost root element name to the wire value declared by the spec (<network_segment>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type NetworkSegments 

type NetworkSegments struct {
	XMLName         xml.Name
	Size            *Size                               `xml:"size,omitempty"`
	NetworkSegments []NetworkSegmentsItemNetworkSegment `xml:"network_segment"`
}

NetworkSegments wraps a Jamf Classic list response with a flat slice of NetworkSegmentsItemNetworkSegment.

func (NetworkSegments) MarshalXML 

func (t NetworkSegments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the NetworkSegments root element name to the wire value declared by the spec (<network_segments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type NetworkSegmentsItem 

type NetworkSegmentsItem struct {
	XMLName        xml.Name
	ID             *int                               `xml:"id,omitempty"`
	NetworkSegment *NetworkSegmentsItemNetworkSegment `xml:"network_segment,omitempty"`
	Size           *Size                              `xml:"size,omitempty"`
}

NetworkSegmentsItem represents a network segments item.

func (NetworkSegmentsItem) MarshalXML 

func (t NetworkSegmentsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the NetworkSegmentsItem root element name to the wire value declared by the spec (<network_segment>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type NetworkSegmentsItemNetworkSegment 

type NetworkSegmentsItemNetworkSegment struct {
	XMLName       xml.Name
	EndingAddress *string `xml:"ending_address,omitempty"`
	ID            *int    `xml:"id,omitempty"`
	// Name of the network segment.
	Name            *string `xml:"name,omitempty"`
	StartingAddress *string `xml:"starting_address,omitempty"`
}

NetworkSegmentsItemNetworkSegment represents a network segments item network segment.

func (NetworkSegmentsItemNetworkSegment) MarshalXML 

func (t NetworkSegmentsItemNetworkSegment) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the NetworkSegmentsItemNetworkSegment root element name to the wire value declared by the spec (<network_segment>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type NotificationValue 

type NotificationValue struct {
	Enabled *bool
	Method  *string
}

NotificationValue captures the self-service notification wire element. The Classic server emits two <notification> tags in one <self_service> block — one a boolean ("true"/"false") and one naming the method ("Self Service", ...). A scalar *bool or *string can only capture the last element, and Go's XML decoder fails outright when it tries to ParseBool the string form. NotificationValue decodes each occurrence into its semantic slot (Enabled or Method) so both pieces of information survive round-trip, and MarshalXML writes them back as separate <notification> elements to preserve the expected wire shape.

func (NotificationValue) MarshalXML 

func (n NotificationValue) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML emits up to two <notification> elements: the method form first if Method is set, then the bool form if Enabled is set. Omits both when neither is set.

Order matters. The Classic server's self_service parser takes the second <notification> as the "primary" value; sending bool first then method silently drops the bool (server returns false on the next GET regardless of what was sent). Wire-probed on a live tenant and confirmed against the order the Jamf Pro admin UI itself writes — method first, bool second — which is the only order that round-trips cleanly for every resource carrying a Notification field.

func (*NotificationValue) UnmarshalXML 

func (n *NotificationValue) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

UnmarshalXML routes the element's text to Enabled when it parses as a bool, otherwise into Method. Called once per <notification> element the decoder encounters in the parent self_service block.

type OsXConfigurationProfile 

type OsXConfigurationProfile struct {
	XMLName     xml.Name
	ID          *int                                `xml:"id,omitempty"`
	General     *OsXConfigurationProfileGeneral     `xml:"general,omitempty"`
	Scope       *OsXConfigurationProfileScope       `xml:"scope,omitempty"`
	SelfService *OsXConfigurationProfileSelfService `xml:"self_service,omitempty"`
}

OsXConfigurationProfile represents a os x configuration profile.

func (OsXConfigurationProfile) MarshalXML 

func (t OsXConfigurationProfile) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfile root element name to the wire value declared by the spec (<os_x_configuration_profile>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileGeneral 

type OsXConfigurationProfileGeneral struct {
	XMLName     xml.Name
	Category    *CategoryObject `xml:"category,omitempty"`
	Description *string         `xml:"description,omitempty"`
	// Allowed values: see the OsXConfigurationProfileGeneralDistributionMethod constants.
	DistributionMethod *string `xml:"distribution_method,omitempty"`
	ID                 *int    `xml:"id,omitempty"`
	// Allowed values: see the OsXConfigurationProfileGeneralLevel constants.
	Level *string `xml:"level,omitempty"`
	// Name of the configuration profile.
	Name             *string          `xml:"name,omitempty"`
	Payloads         *PayloadsXMLText `xml:"payloads,omitempty"`
	RedeployOnUpdate *string          `xml:"redeploy_on_update,omitempty"`
	Site             *SiteObject      `xml:"site,omitempty"`
	UserRemovable    *bool            `xml:"user_removable,omitempty"`
	UUID             *string          `xml:"uuid,omitempty"`
}

OsXConfigurationProfileGeneral represents a os x configuration profile general.

func (OsXConfigurationProfileGeneral) MarshalXML 

func (t OsXConfigurationProfileGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileGeneralDistributionMethod 

type OsXConfigurationProfileGeneralDistributionMethod = string

OsXConfigurationProfileGeneralDistributionMethod is the set of values accepted by OsXConfigurationProfileGeneral.DistributionMethod. 

const (
	OsXConfigurationProfileGeneralDistributionMethodInstallAutomatically       OsXConfigurationProfileGeneralDistributionMethod = "Install Automatically"
	OsXConfigurationProfileGeneralDistributionMethodMakeAvailableInSelfService OsXConfigurationProfileGeneralDistributionMethod = "Make Available in Self Service"
)

OsXConfigurationProfileGeneralDistributionMethod 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 OsXConfigurationProfileGeneralDistributionMethodValues 

func OsXConfigurationProfileGeneralDistributionMethodValues() []OsXConfigurationProfileGeneralDistributionMethod

OsXConfigurationProfileGeneralDistributionMethodValues returns every value the Jamf API accepts for OsXConfigurationProfileGeneralDistributionMethod, 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 OsXConfigurationProfileGeneralLevel 

type OsXConfigurationProfileGeneralLevel = string

OsXConfigurationProfileGeneralLevel is the set of values accepted by OsXConfigurationProfileGeneral.Level. 

const (
	OsXConfigurationProfileGeneralLevelComputer OsXConfigurationProfileGeneralLevel = "computer"
	OsXConfigurationProfileGeneralLevelUser     OsXConfigurationProfileGeneralLevel = "user"
)

OsXConfigurationProfileGeneralLevel 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 OsXConfigurationProfileGeneralLevelValues 

func OsXConfigurationProfileGeneralLevelValues() []OsXConfigurationProfileGeneralLevel

OsXConfigurationProfileGeneralLevelValues returns every value the Jamf API accepts for OsXConfigurationProfileGeneralLevel, 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 OsXConfigurationProfileScope 

type OsXConfigurationProfileScope struct {
	XMLName        xml.Name
	ID             *int                                        `xml:"id,omitempty"`
	AllComputers   *bool                                       `xml:"all_computers,omitempty"`
	AllJssUsers    *bool                                       `xml:"all_jss_users,omitempty"`
	Buildings      *OsXConfigurationProfileScopeBuildings      `xml:"buildings,omitempty"`
	ComputerGroups *OsXConfigurationProfileScopeComputerGroups `xml:"computer_groups,omitempty"`
	Computers      *OsXConfigurationProfileScopeComputers      `xml:"computers,omitempty"`
	Departments    *OsXConfigurationProfileScopeDepartments    `xml:"departments,omitempty"`
	Exclusions     *OsXConfigurationProfileScopeExclusions     `xml:"exclusions,omitempty"`
	JssUserGroups  *OsXConfigurationProfileScopeJssUserGroups  `xml:"jss_user_groups,omitempty"`
	JssUsers       *OsXConfigurationProfileScopeJssUsers       `xml:"jss_users,omitempty"`
	Limitations    *OsXConfigurationProfileScopeLimitations    `xml:"limitations,omitempty"`
}

OsXConfigurationProfileScope represents a os x configuration profile scope.

func (OsXConfigurationProfileScope) MarshalXML 

func (t OsXConfigurationProfileScope) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScope root element name to the wire value declared by the spec (<scope>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeBuildings 

type OsXConfigurationProfileScopeBuildings struct {
	XMLName  xml.Name
	Building *[]IDName `xml:"building,omitempty"`
}

OsXConfigurationProfileScopeBuildings represents a os x configuration profile scope buildings.

func (OsXConfigurationProfileScopeBuildings) MarshalXML 

func (t OsXConfigurationProfileScopeBuildings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeBuildings root element name to the wire value declared by the spec (<buildings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeComputerGroups 

type OsXConfigurationProfileScopeComputerGroups struct {
	XMLName       xml.Name
	ComputerGroup *[]IDName `xml:"computer_group,omitempty"`
}

OsXConfigurationProfileScopeComputerGroups represents a os x configuration profile scope computer groups.

func (OsXConfigurationProfileScopeComputerGroups) MarshalXML 

func (t OsXConfigurationProfileScopeComputerGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeComputerGroups root element name to the wire value declared by the spec (<computer_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeComputers 

type OsXConfigurationProfileScopeComputers struct {
	XMLName  xml.Name
	Computer *[]OsXConfigurationProfileScopeComputersComputerItem `xml:"computer,omitempty"`
}

OsXConfigurationProfileScopeComputers represents a os x configuration profile scope computers.

func (OsXConfigurationProfileScopeComputers) MarshalXML 

func (t OsXConfigurationProfileScopeComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeComputersComputerItem 

type OsXConfigurationProfileScopeComputersComputerItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the computer.
	Name *string `xml:"name,omitempty"`
	UDID *string `xml:"udid,omitempty"`
}

OsXConfigurationProfileScopeComputersComputerItem represents a os x configuration profile scope computers computer item.

func (OsXConfigurationProfileScopeComputersComputerItem) MarshalXML 

func (t OsXConfigurationProfileScopeComputersComputerItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeComputersComputerItem root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeDepartments 

type OsXConfigurationProfileScopeDepartments struct {
	XMLName    xml.Name
	Department *[]IDName `xml:"department,omitempty"`
}

OsXConfigurationProfileScopeDepartments represents a os x configuration profile scope departments.

func (OsXConfigurationProfileScopeDepartments) MarshalXML 

func (t OsXConfigurationProfileScopeDepartments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeDepartments root element name to the wire value declared by the spec (<departments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeExclusions 

type OsXConfigurationProfileScopeExclusions struct {
	XMLName         xml.Name
	ID              *int                                                   `xml:"id,omitempty"`
	Buildings       *OsXConfigurationProfileScopeExclusionsBuildings       `xml:"buildings,omitempty"`
	ComputerGroups  *OsXConfigurationProfileScopeExclusionsComputerGroups  `xml:"computer_groups,omitempty"`
	Computers       *OsXConfigurationProfileScopeExclusionsComputers       `xml:"computers,omitempty"`
	Departments     *OsXConfigurationProfileScopeExclusionsDepartments     `xml:"departments,omitempty"`
	Ibeacons        *OsXConfigurationProfileScopeExclusionsIbeacons        `xml:"ibeacons,omitempty"`
	JssUserGroups   *OsXConfigurationProfileScopeExclusionsJssUserGroups   `xml:"jss_user_groups,omitempty"`
	JssUsers        *OsXConfigurationProfileScopeExclusionsJssUsers        `xml:"jss_users,omitempty"`
	NetworkSegments *OsXConfigurationProfileScopeExclusionsNetworkSegments `xml:"network_segments,omitempty"`
	UserGroups      *OsXConfigurationProfileScopeExclusionsUserGroups      `xml:"user_groups,omitempty"`
	Users           *OsXConfigurationProfileScopeExclusionsUsers           `xml:"users,omitempty"`
}

OsXConfigurationProfileScopeExclusions represents a os x configuration profile scope exclusions.

func (OsXConfigurationProfileScopeExclusions) MarshalXML 

func (t OsXConfigurationProfileScopeExclusions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeExclusions root element name to the wire value declared by the spec (<exclusions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeExclusionsBuildings 

type OsXConfigurationProfileScopeExclusionsBuildings struct {
	XMLName  xml.Name
	Building *[]IDName `xml:"building,omitempty"`
}

OsXConfigurationProfileScopeExclusionsBuildings represents a os x configuration profile scope exclusions buildings.

func (OsXConfigurationProfileScopeExclusionsBuildings) MarshalXML 

func (t OsXConfigurationProfileScopeExclusionsBuildings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeExclusionsBuildings root element name to the wire value declared by the spec (<buildings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeExclusionsComputerGroups 

type OsXConfigurationProfileScopeExclusionsComputerGroups struct {
	XMLName       xml.Name
	ComputerGroup *[]IDName `xml:"computer_group,omitempty"`
}

OsXConfigurationProfileScopeExclusionsComputerGroups represents a os x configuration profile scope exclusions computer groups.

func (OsXConfigurationProfileScopeExclusionsComputerGroups) MarshalXML 

func (t OsXConfigurationProfileScopeExclusionsComputerGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeExclusionsComputerGroups root element name to the wire value declared by the spec (<computer_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeExclusionsComputers 

type OsXConfigurationProfileScopeExclusionsComputers struct {
	XMLName  xml.Name
	Computer *[]OsXConfigurationProfileScopeExclusionsComputersComputerItem `xml:"computer,omitempty"`
}

OsXConfigurationProfileScopeExclusionsComputers represents a os x configuration profile scope exclusions computers.

func (OsXConfigurationProfileScopeExclusionsComputers) MarshalXML 

func (t OsXConfigurationProfileScopeExclusionsComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeExclusionsComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeExclusionsComputersComputerItem 

type OsXConfigurationProfileScopeExclusionsComputersComputerItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the computer.
	Name *string `xml:"name,omitempty"`
	UDID *string `xml:"udid,omitempty"`
}

OsXConfigurationProfileScopeExclusionsComputersComputerItem represents a os x configuration profile scope exclusions computers computer item.

func (OsXConfigurationProfileScopeExclusionsComputersComputerItem) MarshalXML 

func (t OsXConfigurationProfileScopeExclusionsComputersComputerItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeExclusionsComputersComputerItem root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeExclusionsDepartments 

type OsXConfigurationProfileScopeExclusionsDepartments struct {
	XMLName    xml.Name
	Department *[]IDName `xml:"department,omitempty"`
}

OsXConfigurationProfileScopeExclusionsDepartments represents a os x configuration profile scope exclusions departments.

func (OsXConfigurationProfileScopeExclusionsDepartments) MarshalXML 

func (t OsXConfigurationProfileScopeExclusionsDepartments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeExclusionsDepartments root element name to the wire value declared by the spec (<departments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeExclusionsIbeacons 

type OsXConfigurationProfileScopeExclusionsIbeacons struct {
	XMLName xml.Name
	Ibeacon *[]IDName `xml:"ibeacon,omitempty"`
}

OsXConfigurationProfileScopeExclusionsIbeacons represents a os x configuration profile scope exclusions ibeacons.

func (OsXConfigurationProfileScopeExclusionsIbeacons) MarshalXML 

func (t OsXConfigurationProfileScopeExclusionsIbeacons) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeExclusionsIbeacons root element name to the wire value declared by the spec (<ibeacons>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeExclusionsJssUserGroups 

type OsXConfigurationProfileScopeExclusionsJssUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

OsXConfigurationProfileScopeExclusionsJssUserGroups represents a os x configuration profile scope exclusions jss user groups.

func (OsXConfigurationProfileScopeExclusionsJssUserGroups) MarshalXML 

func (t OsXConfigurationProfileScopeExclusionsJssUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeExclusionsJssUserGroups root element name to the wire value declared by the spec (<jss_user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeExclusionsJssUsers 

type OsXConfigurationProfileScopeExclusionsJssUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

OsXConfigurationProfileScopeExclusionsJssUsers represents a os x configuration profile scope exclusions jss users.

func (OsXConfigurationProfileScopeExclusionsJssUsers) MarshalXML 

func (t OsXConfigurationProfileScopeExclusionsJssUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeExclusionsJssUsers root element name to the wire value declared by the spec (<jss_users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeExclusionsNetworkSegments 

type OsXConfigurationProfileScopeExclusionsNetworkSegments struct {
	XMLName        xml.Name
	NetworkSegment *[]OsXConfigurationProfileScopeExclusionsNetworkSegmentsNetworkSegmentItem `xml:"network_segment,omitempty"`
}

OsXConfigurationProfileScopeExclusionsNetworkSegments represents a os x configuration profile scope exclusions network segments.

func (OsXConfigurationProfileScopeExclusionsNetworkSegments) MarshalXML 

func (t OsXConfigurationProfileScopeExclusionsNetworkSegments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeExclusionsNetworkSegments root element name to the wire value declared by the spec (<network_segments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeExclusionsNetworkSegmentsNetworkSegmentItem 

type OsXConfigurationProfileScopeExclusionsNetworkSegmentsNetworkSegmentItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the network segment.
	Name *string `xml:"name,omitempty"`
	Uid  *string `xml:"uid,omitempty"`
}

OsXConfigurationProfileScopeExclusionsNetworkSegmentsNetworkSegmentItem represents a os x configuration profile scope exclusions network segments network segment item.

func (OsXConfigurationProfileScopeExclusionsNetworkSegmentsNetworkSegmentItem) MarshalXML 

func (t OsXConfigurationProfileScopeExclusionsNetworkSegmentsNetworkSegmentItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeExclusionsNetworkSegmentsNetworkSegmentItem root element name to the wire value declared by the spec (<network_segment>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeExclusionsUserGroups 

type OsXConfigurationProfileScopeExclusionsUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

OsXConfigurationProfileScopeExclusionsUserGroups represents a os x configuration profile scope exclusions user groups.

func (OsXConfigurationProfileScopeExclusionsUserGroups) MarshalXML 

func (t OsXConfigurationProfileScopeExclusionsUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeExclusionsUserGroups root element name to the wire value declared by the spec (<user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeExclusionsUsers 

type OsXConfigurationProfileScopeExclusionsUsers struct {
	XMLName xml.Name
	User    *[]OsXConfigurationProfileScopeExclusionsUsersUserItem `xml:"user,omitempty"`
}

OsXConfigurationProfileScopeExclusionsUsers represents a os x configuration profile scope exclusions users.

func (OsXConfigurationProfileScopeExclusionsUsers) MarshalXML 

func (t OsXConfigurationProfileScopeExclusionsUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeExclusionsUsers root element name to the wire value declared by the spec (<users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeExclusionsUsersUserItem 

type OsXConfigurationProfileScopeExclusionsUsersUserItem struct {
	XMLName xml.Name
	Name    *string `xml:"name,omitempty"`
}

OsXConfigurationProfileScopeExclusionsUsersUserItem represents a os x configuration profile scope exclusions users user item.

func (OsXConfigurationProfileScopeExclusionsUsersUserItem) MarshalXML 

func (t OsXConfigurationProfileScopeExclusionsUsersUserItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeExclusionsUsersUserItem root element name to the wire value declared by the spec (<user>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeJssUserGroups 

type OsXConfigurationProfileScopeJssUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

OsXConfigurationProfileScopeJssUserGroups represents a os x configuration profile scope jss user groups.

func (OsXConfigurationProfileScopeJssUserGroups) MarshalXML 

func (t OsXConfigurationProfileScopeJssUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeJssUserGroups root element name to the wire value declared by the spec (<jss_user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeJssUsers 

type OsXConfigurationProfileScopeJssUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

OsXConfigurationProfileScopeJssUsers represents a os x configuration profile scope jss users.

func (OsXConfigurationProfileScopeJssUsers) MarshalXML 

func (t OsXConfigurationProfileScopeJssUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeJssUsers root element name to the wire value declared by the spec (<jss_users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeLimitations 

type OsXConfigurationProfileScopeLimitations struct {
	XMLName         xml.Name
	ID              *int                                                    `xml:"id,omitempty"`
	Ibeacons        *OsXConfigurationProfileScopeLimitationsIbeacons        `xml:"ibeacons,omitempty"`
	NetworkSegments *OsXConfigurationProfileScopeLimitationsNetworkSegments `xml:"network_segments,omitempty"`
	UserGroups      *OsXConfigurationProfileScopeLimitationsUserGroups      `xml:"user_groups,omitempty"`
	Users           *OsXConfigurationProfileScopeLimitationsUsers           `xml:"users,omitempty"`
}

OsXConfigurationProfileScopeLimitations represents a os x configuration profile scope limitations.

func (OsXConfigurationProfileScopeLimitations) MarshalXML 

func (t OsXConfigurationProfileScopeLimitations) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeLimitations root element name to the wire value declared by the spec (<limitations>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeLimitationsIbeacons 

type OsXConfigurationProfileScopeLimitationsIbeacons struct {
	XMLName xml.Name
	Ibeacon *[]IDName `xml:"ibeacon,omitempty"`
}

OsXConfigurationProfileScopeLimitationsIbeacons represents a os x configuration profile scope limitations ibeacons.

func (OsXConfigurationProfileScopeLimitationsIbeacons) MarshalXML 

func (t OsXConfigurationProfileScopeLimitationsIbeacons) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeLimitationsIbeacons root element name to the wire value declared by the spec (<ibeacons>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeLimitationsNetworkSegments 

type OsXConfigurationProfileScopeLimitationsNetworkSegments struct {
	XMLName        xml.Name
	NetworkSegment *[]OsXConfigurationProfileScopeLimitationsNetworkSegmentsNetworkSegmentItem `xml:"network_segment,omitempty"`
}

OsXConfigurationProfileScopeLimitationsNetworkSegments represents a os x configuration profile scope limitations network segments.

func (OsXConfigurationProfileScopeLimitationsNetworkSegments) MarshalXML 

func (t OsXConfigurationProfileScopeLimitationsNetworkSegments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeLimitationsNetworkSegments root element name to the wire value declared by the spec (<network_segments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeLimitationsNetworkSegmentsNetworkSegmentItem 

type OsXConfigurationProfileScopeLimitationsNetworkSegmentsNetworkSegmentItem struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
	Uid     *string `xml:"uid,omitempty"`
}

OsXConfigurationProfileScopeLimitationsNetworkSegmentsNetworkSegmentItem represents a os x configuration profile scope limitations network segments network segment item.

func (OsXConfigurationProfileScopeLimitationsNetworkSegmentsNetworkSegmentItem) MarshalXML 

func (t OsXConfigurationProfileScopeLimitationsNetworkSegmentsNetworkSegmentItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeLimitationsNetworkSegmentsNetworkSegmentItem root element name to the wire value declared by the spec (<network_segment>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeLimitationsUserGroups 

type OsXConfigurationProfileScopeLimitationsUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

OsXConfigurationProfileScopeLimitationsUserGroups represents a os x configuration profile scope limitations user groups.

func (OsXConfigurationProfileScopeLimitationsUserGroups) MarshalXML 

func (t OsXConfigurationProfileScopeLimitationsUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeLimitationsUserGroups root element name to the wire value declared by the spec (<user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileScopeLimitationsUsers 

type OsXConfigurationProfileScopeLimitationsUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

OsXConfigurationProfileScopeLimitationsUsers represents a os x configuration profile scope limitations users.

func (OsXConfigurationProfileScopeLimitationsUsers) MarshalXML 

func (t OsXConfigurationProfileScopeLimitationsUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileScopeLimitationsUsers root element name to the wire value declared by the spec (<users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileSelfService 

type OsXConfigurationProfileSelfService struct {
	XMLName                     xml.Name
	ID                          *int                                                     `xml:"id,omitempty"`
	FeatureOnMainPage           *bool                                                    `xml:"feature_on_main_page,omitempty"`
	ForceUsersToViewDescription *bool                                                    `xml:"force_users_to_view_description,omitempty"`
	InstallButtonText           *string                                                  `xml:"install_button_text,omitempty"`
	Notification                *NotificationValue                                       `xml:"notification"`
	NotificationMessage         *string                                                  `xml:"notification_message,omitempty"`
	NotificationSubject         *string                                                  `xml:"notification_subject,omitempty"`
	Security                    *OsXConfigurationProfileSelfServiceSecurity              `xml:"security,omitempty"`
	SelfServiceCategories       *OsXConfigurationProfileSelfServiceSelfServiceCategories `xml:"self_service_categories,omitempty"`
	SelfServiceDescription      *string                                                  `xml:"self_service_description,omitempty"`
	SelfServiceDisplayName      *string                                                  `xml:"self_service_display_name,omitempty"`
	SelfServiceIcon             *OsXConfigurationProfileSelfServiceSelfServiceIcon       `xml:"self_service_icon,omitempty"`
}

OsXConfigurationProfileSelfService represents a os x configuration profile self service.

func (OsXConfigurationProfileSelfService) MarshalXML 

func (t OsXConfigurationProfileSelfService) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileSelfService root element name to the wire value declared by the spec (<self_service>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileSelfServiceSecurity 

type OsXConfigurationProfileSelfServiceSecurity struct {
	XMLName           xml.Name
	Password          *string `xml:"password,omitempty"`
	RemovalDisallowed *string `xml:"removal_disallowed,omitempty"`
}

OsXConfigurationProfileSelfServiceSecurity represents a os x configuration profile self service security.

func (OsXConfigurationProfileSelfServiceSecurity) MarshalXML 

func (t OsXConfigurationProfileSelfServiceSecurity) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileSelfServiceSecurity root element name to the wire value declared by the spec (<security>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileSelfServiceSelfServiceCategories 

type OsXConfigurationProfileSelfServiceSelfServiceCategories struct {
	XMLName  xml.Name
	Category *[]OsXConfigurationProfileSelfServiceSelfServiceCategoriesCategoryItem `xml:"category,omitempty"`
}

OsXConfigurationProfileSelfServiceSelfServiceCategories represents a os x configuration profile self service self service categories.

func (OsXConfigurationProfileSelfServiceSelfServiceCategories) MarshalXML 

func (t OsXConfigurationProfileSelfServiceSelfServiceCategories) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileSelfServiceSelfServiceCategories root element name to the wire value declared by the spec (<self_service_categories>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileSelfServiceSelfServiceCategoriesCategoryItem 

type OsXConfigurationProfileSelfServiceSelfServiceCategoriesCategoryItem struct {
	XMLName   xml.Name
	DisplayIn *bool   `xml:"display_in,omitempty"`
	FeatureIn *bool   `xml:"feature_in,omitempty"`
	ID        *int    `xml:"id,omitempty"`
	Name      *string `xml:"name,omitempty"`
}

OsXConfigurationProfileSelfServiceSelfServiceCategoriesCategoryItem represents a os x configuration profile self service self service categories category item.

func (OsXConfigurationProfileSelfServiceSelfServiceCategoriesCategoryItem) MarshalXML 

func (t OsXConfigurationProfileSelfServiceSelfServiceCategoriesCategoryItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileSelfServiceSelfServiceCategoriesCategoryItem root element name to the wire value declared by the spec (<category>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfileSelfServiceSelfServiceIcon 

type OsXConfigurationProfileSelfServiceSelfServiceIcon struct {
	XMLName xml.Name
	Data    *string `xml:"data,omitempty"`
	ID      *int    `xml:"id,omitempty"`
	URI     *string `xml:"uri,omitempty"`
}

OsXConfigurationProfileSelfServiceSelfServiceIcon represents a os x configuration profile self service self service icon.

func (OsXConfigurationProfileSelfServiceSelfServiceIcon) MarshalXML 

func (t OsXConfigurationProfileSelfServiceSelfServiceIcon) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfileSelfServiceSelfServiceIcon root element name to the wire value declared by the spec (<self_service_icon>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfiles 

type OsXConfigurationProfiles struct {
	XMLName                  xml.Name
	Size                     *Size    `xml:"size,omitempty"`
	OsXConfigurationProfiles []IDName `xml:"os_x_configuration_profile"`
}

OsXConfigurationProfiles wraps a Jamf Classic list response with a flat slice of IDName.

func (OsXConfigurationProfiles) MarshalXML 

func (t OsXConfigurationProfiles) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfiles root element name to the wire value declared by the spec (<os_x_configuration_profiles>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type OsXConfigurationProfilesItem 

type OsXConfigurationProfilesItem struct {
	XMLName                 xml.Name
	ID                      *int    `xml:"id,omitempty"`
	OsXConfigurationProfile *IDName `xml:"os_x_configuration_profile,omitempty"`
	Size                    *Size   `xml:"size,omitempty"`
}

OsXConfigurationProfilesItem represents a os x configuration profiles item.

func (OsXConfigurationProfilesItem) MarshalXML 

func (t OsXConfigurationProfilesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the OsXConfigurationProfilesItem root element name to the wire value declared by the spec (<os_x_configuration_profile>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Package 

type Package struct {
	XMLName                    xml.Name
	AllowUninstalled           *bool   `xml:"allow_uninstalled,omitempty"`
	Category                   *string `xml:"category,omitempty"`
	Filename                   *string `xml:"filename,omitempty"`
	FillExistingUsers          *bool   `xml:"fill_existing_users,omitempty"`
	FillUserTemplate           *bool   `xml:"fill_user_template,omitempty"`
	HashType                   *string `xml:"hash_type,omitempty"`
	HashValue                  *string `xml:"hash_value,omitempty"`
	ID                         *int    `xml:"id,omitempty"`
	Info                       *string `xml:"info,omitempty"`
	InstallIfReportedAvailable *bool   `xml:"install_if_reported_available,omitempty"`
	// Name of the package.
	Name            *string `xml:"name,omitempty"`
	Notes           *string `xml:"notes,omitempty"`
	OsRequirements  *string `xml:"os_requirements,omitempty"`
	Priority        *int    `xml:"priority,omitempty"`
	RebootRequired  *bool   `xml:"reboot_required,omitempty"`
	ReinstallOption *string `xml:"reinstall_option,omitempty"`
	// Allowed values: see the PackageRequiredProcessor constants.
	RequiredProcessor *string `xml:"required_processor,omitempty"`
	SendNotification  *bool   `xml:"send_notification,omitempty"`
	SwitchWithPackage *string `xml:"switch_with_package,omitempty"`
	TriggeringFiles   *string `xml:"triggering_files,omitempty"`
}

Package represents a package.

func (Package) MarshalXML 

func (t Package) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Package root element name to the wire value declared by the spec (<package>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PackageRequiredProcessor 

type PackageRequiredProcessor = string

PackageRequiredProcessor is the set of values accepted by Package.RequiredProcessor. 

const (
	PackageRequiredProcessorNone PackageRequiredProcessor = "None"
	PackageRequiredProcessorPpc  PackageRequiredProcessor = "ppc"
	PackageRequiredProcessorX86  PackageRequiredProcessor = "x86"
)

PackageRequiredProcessor 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 PackageRequiredProcessorValues 

func PackageRequiredProcessorValues() []PackageRequiredProcessor

PackageRequiredProcessorValues returns every value the Jamf API accepts for PackageRequiredProcessor, 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 Packages 

type Packages struct {
	XMLName  xml.Name
	Size     *Size    `xml:"size,omitempty"`
	Packages []IDName `xml:"package"`
}

Packages wraps a Jamf Classic list response with a flat slice of IDName.

func (Packages) MarshalXML 

func (t Packages) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Packages root element name to the wire value declared by the spec (<packages>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PackagesItem 

type PackagesItem struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Package *IDName `xml:"package,omitempty"`
	Size    *Size   `xml:"size,omitempty"`
}

PackagesItem represents a packages item.

func (PackagesItem) MarshalXML 

func (t PackagesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PackagesItem root element name to the wire value declared by the spec (<package>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchAvailableTitles 

type PatchAvailableTitles struct {
	XMLName         xml.Name
	ID              *int                                 `xml:"id,omitempty"`
	AvailableTitles *PatchAvailableTitlesAvailableTitles `xml:"available_titles,omitempty"`
	Size            *Size                                `xml:"size,omitempty"`
}

PatchAvailableTitles represents a patch available titles.

func (PatchAvailableTitles) MarshalXML 

func (t PatchAvailableTitles) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchAvailableTitles root element name to the wire value declared by the spec (<patch_available_titles>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchAvailableTitlesAvailableTitles 

type PatchAvailableTitlesAvailableTitles struct {
	XMLName        xml.Name
	AvailableTitle *[]PatchAvailableTitlesAvailableTitlesAvailableTitleItem `xml:"available_title,omitempty"`
}

PatchAvailableTitlesAvailableTitles represents a patch available titles available titles.

func (PatchAvailableTitlesAvailableTitles) MarshalXML 

func (t PatchAvailableTitlesAvailableTitles) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchAvailableTitlesAvailableTitles root element name to the wire value declared by the spec (<available_titles>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchAvailableTitlesAvailableTitlesAvailableTitleItem 

type PatchAvailableTitlesAvailableTitlesAvailableTitleItem struct {
	XMLName        xml.Name
	AppName        *string `xml:"app_name,omitempty"`
	CurrentVersion *string `xml:"current_version,omitempty"`
	LastModified   *string `xml:"last_modified,omitempty"`
	NameID         *string `xml:"name_id,omitempty"`
	Publisher      *string `xml:"publisher,omitempty"`
}

PatchAvailableTitlesAvailableTitlesAvailableTitleItem represents a patch available titles available titles available title item.

func (PatchAvailableTitlesAvailableTitlesAvailableTitleItem) MarshalXML 

func (t PatchAvailableTitlesAvailableTitlesAvailableTitleItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchAvailableTitlesAvailableTitlesAvailableTitleItem root element name to the wire value declared by the spec (<available_title>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchExternalSource 

type PatchExternalSource struct {
	XMLName                      xml.Name
	CertificateValidationEnabled *bool   `xml:"certificate_validation_enabled,omitempty"`
	Enabled                      *bool   `xml:"enabled,omitempty"`
	HostName                     *string `xml:"host_name,omitempty"`
	ID                           *int    `xml:"id,omitempty"`
	Name                         *string `xml:"name,omitempty"`
	Port                         *int    `xml:"port,omitempty"`
	SslEnabled                   *bool   `xml:"ssl_enabled,omitempty"`
}

PatchExternalSource represents a patch external source.

func (PatchExternalSource) MarshalXML 

func (t PatchExternalSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchExternalSource root element name to the wire value declared by the spec (<patch_external_source>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchExternalSources 

type PatchExternalSources struct {
	XMLName              xml.Name
	Size                 *Size    `xml:"size,omitempty"`
	PatchExternalSources []IDName `xml:"patch_external_source"`
}

PatchExternalSources wraps a Jamf Classic list response with a flat slice of IDName.

func (PatchExternalSources) MarshalXML 

func (t PatchExternalSources) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchExternalSources root element name to the wire value declared by the spec (<patch_external_sources>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchExternalSourcesItem 

type PatchExternalSourcesItem struct {
	XMLName             xml.Name
	ID                  *int    `xml:"id,omitempty"`
	PatchExternalSource *IDName `xml:"patch_external_source,omitempty"`
	Size                *Size   `xml:"size,omitempty"`
}

PatchExternalSourcesItem represents a patch external sources item.

func (PatchExternalSourcesItem) MarshalXML 

func (t PatchExternalSourcesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchExternalSourcesItem root element name to the wire value declared by the spec (<patch_external_source>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchInternalSource 

type PatchInternalSource struct {
	XMLName  xml.Name
	Enabled  *bool   `xml:"enabled,omitempty"`
	Endpoint *string `xml:"endpoint,omitempty"`
	ID       *int    `xml:"id,omitempty"`
	Name     *string `xml:"name,omitempty"`
}

PatchInternalSource represents a patch internal source.

func (PatchInternalSource) MarshalXML 

func (t PatchInternalSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchInternalSource root element name to the wire value declared by the spec (<patch_internal_source>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchInternalSources 

type PatchInternalSources struct {
	XMLName              xml.Name
	Size                 *Size    `xml:"size,omitempty"`
	PatchInternalSources []IDName `xml:"patch_internal_source"`
}

PatchInternalSources wraps a Jamf Classic list response with a flat slice of IDName.

func (PatchInternalSources) MarshalXML 

func (t PatchInternalSources) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchInternalSources root element name to the wire value declared by the spec (<patch_internal_sources>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchInternalSourcesItem 

type PatchInternalSourcesItem struct {
	XMLName             xml.Name
	ID                  *int    `xml:"id,omitempty"`
	PatchInternalSource *IDName `xml:"patch_internal_source,omitempty"`
	Size                *Size   `xml:"size,omitempty"`
}

PatchInternalSourcesItem represents a patch internal sources item.

func (PatchInternalSourcesItem) MarshalXML 

func (t PatchInternalSourcesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchInternalSourcesItem root element name to the wire value declared by the spec (<patch_internal_source>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchManagementSoftwareTitles 

type PatchManagementSoftwareTitles struct {
	XMLName                       xml.Name
	Size                          *Size                                                           `xml:"size,omitempty"`
	PatchManagementSoftwareTitles []PatchManagementSoftwareTitlesItemPatchManagementSoftwareTitle `xml:"patch_management_software_title"`
}

PatchManagementSoftwareTitles wraps a Jamf Classic list response with a flat slice of PatchManagementSoftwareTitlesItemPatchManagementSoftwareTitle.

func (PatchManagementSoftwareTitles) MarshalXML 

func (t PatchManagementSoftwareTitles) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchManagementSoftwareTitles root element name to the wire value declared by the spec (<patch_management_software_titles>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchManagementSoftwareTitlesItem 

type PatchManagementSoftwareTitlesItem struct {
	XMLName                      xml.Name
	ID                           *int                                                           `xml:"id,omitempty"`
	PatchManagementSoftwareTitle *PatchManagementSoftwareTitlesItemPatchManagementSoftwareTitle `xml:"patch_management_software_title,omitempty"`
	Size                         *Size                                                          `xml:"size,omitempty"`
}

PatchManagementSoftwareTitlesItem represents a patch management software titles item.

func (PatchManagementSoftwareTitlesItem) MarshalXML 

func (t PatchManagementSoftwareTitlesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchManagementSoftwareTitlesItem root element name to the wire value declared by the spec (<patch_management_software_title>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchManagementSoftwareTitlesItemPatchManagementSoftwareTitle 

type PatchManagementSoftwareTitlesItemPatchManagementSoftwareTitle struct {
	XMLName  xml.Name
	ID       *int    `xml:"id,omitempty"`
	Name     *string `xml:"name,omitempty"`
	NameID   *string `xml:"name_id,omitempty"`
	SourceID *int    `xml:"source_id,omitempty"`
}

PatchManagementSoftwareTitlesItemPatchManagementSoftwareTitle represents a patch management software titles item patch management software title.

func (PatchManagementSoftwareTitlesItemPatchManagementSoftwareTitle) MarshalXML 

func (t PatchManagementSoftwareTitlesItemPatchManagementSoftwareTitle) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchManagementSoftwareTitlesItemPatchManagementSoftwareTitle root element name to the wire value declared by the spec (<patch_management_software_title>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicies 

type PatchPolicies struct {
	XMLName       xml.Name
	Size          *Size    `xml:"size,omitempty"`
	PatchPolicies []IDName `xml:"patch_policy"`
}

PatchPolicies wraps a Jamf Classic list response with a flat slice of IDName.

func (PatchPolicies) MarshalXML 

func (t PatchPolicies) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicies root element name to the wire value declared by the spec (<patch_policies>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPoliciesItem 

type PatchPoliciesItem struct {
	XMLName     xml.Name
	ID          *int    `xml:"id,omitempty"`
	PatchPolicy *IDName `xml:"patch_policy,omitempty"`
	Size        *Size   `xml:"size,omitempty"`
}

PatchPoliciesItem represents a patch policies item.

func (PatchPoliciesItem) MarshalXML 

func (t PatchPoliciesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPoliciesItem root element name to the wire value declared by the spec (<patch_policy>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicy 

type PatchPolicy struct {
	XMLName                      xml.Name
	ID                           *int                        `xml:"id,omitempty"`
	General                      *PatchPolicyGeneral         `xml:"general,omitempty"`
	Scope                        *PatchPolicyScope           `xml:"scope,omitempty"`
	SoftwareTitleConfigurationID *int                        `xml:"software_title_configuration_id,omitempty"`
	UserInteraction              *PatchPolicyUserInteraction `xml:"user_interaction,omitempty"`
}

PatchPolicy represents a patch policy.

func (PatchPolicy) MarshalXML 

func (t PatchPolicy) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicy root element name to the wire value declared by the spec (<patch_policy>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyGeneral 

type PatchPolicyGeneral struct {
	XMLName        xml.Name
	AllowDowngrade *bool `xml:"allow_downgrade,omitempty"`
	// Allowed values: see the PatchPolicyGeneralDistributionMethod constants.
	DistributionMethod *string                     `xml:"distribution_method,omitempty"`
	Enabled            *bool                       `xml:"enabled,omitempty"`
	ID                 *int                        `xml:"id,omitempty"`
	IncrementalUpdate  *bool                       `xml:"incremental_update,omitempty"`
	KillApps           *PatchPolicyGeneralKillApps `xml:"kill_apps,omitempty"`
	MinimumOs          *string                     `xml:"minimum_os,omitempty"`
	Name               *string                     `xml:"name,omitempty"`
	// Set to true to patch versions unidentified by Jamf Pro patch reporting.
	PatchUnknown  *bool   `xml:"patch_unknown,omitempty"`
	Reboot        *bool   `xml:"reboot,omitempty"`
	ReleaseDate   *int    `xml:"release_date,omitempty"`
	TargetVersion *string `xml:"target_version,omitempty"`
}

PatchPolicyGeneral represents a patch policy general.

func (PatchPolicyGeneral) MarshalXML 

func (t PatchPolicyGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyGeneralDistributionMethod 

type PatchPolicyGeneralDistributionMethod = string

PatchPolicyGeneralDistributionMethod is the set of values accepted by PatchPolicyGeneral.DistributionMethod. 

const (
	PatchPolicyGeneralDistributionMethodSelfservice PatchPolicyGeneralDistributionMethod = "selfservice"
	PatchPolicyGeneralDistributionMethodPrompt      PatchPolicyGeneralDistributionMethod = "prompt"
)

PatchPolicyGeneralDistributionMethod 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 PatchPolicyGeneralDistributionMethodValues 

func PatchPolicyGeneralDistributionMethodValues() []PatchPolicyGeneralDistributionMethod

PatchPolicyGeneralDistributionMethodValues returns every value the Jamf API accepts for PatchPolicyGeneralDistributionMethod, 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 PatchPolicyGeneralKillApps 

type PatchPolicyGeneralKillApps struct {
	XMLName xml.Name
	KillApp *[]PatchPolicyGeneralKillAppsKillAppItem `xml:"kill_app,omitempty"`
}

PatchPolicyGeneralKillApps represents a patch policy general kill apps.

func (PatchPolicyGeneralKillApps) MarshalXML 

func (t PatchPolicyGeneralKillApps) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyGeneralKillApps root element name to the wire value declared by the spec (<kill_apps>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyGeneralKillAppsKillAppItem 

type PatchPolicyGeneralKillAppsKillAppItem struct {
	XMLName         xml.Name
	KillAppBundleID *string `xml:"kill_app_bundle_id,omitempty"`
	KillAppName     *string `xml:"kill_app_name,omitempty"`
}

PatchPolicyGeneralKillAppsKillAppItem represents a patch policy general kill apps kill app item.

func (PatchPolicyGeneralKillAppsKillAppItem) MarshalXML 

func (t PatchPolicyGeneralKillAppsKillAppItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyGeneralKillAppsKillAppItem root element name to the wire value declared by the spec (<kill_app>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyScope 

type PatchPolicyScope struct {
	XMLName        xml.Name
	ID             *int                            `xml:"id,omitempty"`
	AllComputers   *bool                           `xml:"all_computers,omitempty"`
	Buildings      *PatchPolicyScopeBuildings      `xml:"buildings,omitempty"`
	ComputerGroups *PatchPolicyScopeComputerGroups `xml:"computer_groups,omitempty"`
	Computers      *PatchPolicyScopeComputers      `xml:"computers,omitempty"`
	Departments    *PatchPolicyScopeDepartments    `xml:"departments,omitempty"`
	Exclusions     *PatchPolicyScopeExclusions     `xml:"exclusions,omitempty"`
	Limitations    *PatchPolicyScopeLimitations    `xml:"limitations,omitempty"`
}

PatchPolicyScope represents a patch policy scope.

func (PatchPolicyScope) MarshalXML 

func (t PatchPolicyScope) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyScope root element name to the wire value declared by the spec (<scope>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyScopeBuildings 

type PatchPolicyScopeBuildings struct {
	XMLName  xml.Name
	Building *[]IDName `xml:"building,omitempty"`
}

PatchPolicyScopeBuildings represents a patch policy scope buildings.

func (PatchPolicyScopeBuildings) MarshalXML 

func (t PatchPolicyScopeBuildings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyScopeBuildings root element name to the wire value declared by the spec (<buildings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyScopeComputerGroups 

type PatchPolicyScopeComputerGroups struct {
	XMLName       xml.Name
	ComputerGroup *[]IDName `xml:"computer_group,omitempty"`
}

PatchPolicyScopeComputerGroups represents a patch policy scope computer groups.

func (PatchPolicyScopeComputerGroups) MarshalXML 

func (t PatchPolicyScopeComputerGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyScopeComputerGroups root element name to the wire value declared by the spec (<computer_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyScopeComputers 

type PatchPolicyScopeComputers struct {
	XMLName  xml.Name
	Computer *[]PatchPolicyScopeComputersComputerItem `xml:"computer,omitempty"`
}

PatchPolicyScopeComputers represents a patch policy scope computers.

func (PatchPolicyScopeComputers) MarshalXML 

func (t PatchPolicyScopeComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyScopeComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyScopeComputersComputerItem 

type PatchPolicyScopeComputersComputerItem struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
	UDID    *string `xml:"udid,omitempty"`
}

PatchPolicyScopeComputersComputerItem represents a patch policy scope computers computer item.

func (PatchPolicyScopeComputersComputerItem) MarshalXML 

func (t PatchPolicyScopeComputersComputerItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyScopeComputersComputerItem root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyScopeDepartments 

type PatchPolicyScopeDepartments struct {
	XMLName    xml.Name
	Department *[]IDName `xml:"department,omitempty"`
}

PatchPolicyScopeDepartments represents a patch policy scope departments.

func (PatchPolicyScopeDepartments) MarshalXML 

func (t PatchPolicyScopeDepartments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyScopeDepartments root element name to the wire value declared by the spec (<departments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyScopeExclusions 

type PatchPolicyScopeExclusions struct {
	XMLName         xml.Name
	ID              *int                                       `xml:"id,omitempty"`
	Buildings       *PatchPolicyScopeExclusionsBuildings       `xml:"buildings,omitempty"`
	ComputerGroups  *PatchPolicyScopeExclusionsComputerGroups  `xml:"computer_groups,omitempty"`
	Computers       *PatchPolicyScopeExclusionsComputers       `xml:"computers,omitempty"`
	Departments     *PatchPolicyScopeExclusionsDepartments     `xml:"departments,omitempty"`
	Ibeacons        *PatchPolicyScopeExclusionsIbeacons        `xml:"ibeacons,omitempty"`
	NetworkSegments *PatchPolicyScopeExclusionsNetworkSegments `xml:"network_segments,omitempty"`
}

PatchPolicyScopeExclusions represents a patch policy scope exclusions.

func (PatchPolicyScopeExclusions) MarshalXML 

func (t PatchPolicyScopeExclusions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyScopeExclusions root element name to the wire value declared by the spec (<exclusions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyScopeExclusionsBuildings 

type PatchPolicyScopeExclusionsBuildings struct {
	XMLName  xml.Name
	Building *[]IDName `xml:"building,omitempty"`
}

PatchPolicyScopeExclusionsBuildings represents a patch policy scope exclusions buildings.

func (PatchPolicyScopeExclusionsBuildings) MarshalXML 

func (t PatchPolicyScopeExclusionsBuildings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyScopeExclusionsBuildings root element name to the wire value declared by the spec (<buildings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyScopeExclusionsComputerGroups 

type PatchPolicyScopeExclusionsComputerGroups struct {
	XMLName       xml.Name
	ComputerGroup *[]IDName `xml:"computer_group,omitempty"`
}

PatchPolicyScopeExclusionsComputerGroups represents a patch policy scope exclusions computer groups.

func (PatchPolicyScopeExclusionsComputerGroups) MarshalXML 

func (t PatchPolicyScopeExclusionsComputerGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyScopeExclusionsComputerGroups root element name to the wire value declared by the spec (<computer_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyScopeExclusionsComputers 

type PatchPolicyScopeExclusionsComputers struct {
	XMLName  xml.Name
	Computer *[]PatchPolicyScopeExclusionsComputersComputerItem `xml:"computer,omitempty"`
}

PatchPolicyScopeExclusionsComputers represents a patch policy scope exclusions computers.

func (PatchPolicyScopeExclusionsComputers) MarshalXML 

func (t PatchPolicyScopeExclusionsComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyScopeExclusionsComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyScopeExclusionsComputersComputerItem 

type PatchPolicyScopeExclusionsComputersComputerItem struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
	UDID    *string `xml:"udid,omitempty"`
}

PatchPolicyScopeExclusionsComputersComputerItem represents a patch policy scope exclusions computers computer item.

func (PatchPolicyScopeExclusionsComputersComputerItem) MarshalXML 

func (t PatchPolicyScopeExclusionsComputersComputerItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyScopeExclusionsComputersComputerItem root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyScopeExclusionsDepartments 

type PatchPolicyScopeExclusionsDepartments struct {
	XMLName    xml.Name
	Department *[]IDName `xml:"department,omitempty"`
}

PatchPolicyScopeExclusionsDepartments represents a patch policy scope exclusions departments.

func (PatchPolicyScopeExclusionsDepartments) MarshalXML 

func (t PatchPolicyScopeExclusionsDepartments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyScopeExclusionsDepartments root element name to the wire value declared by the spec (<departments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyScopeExclusionsIbeacons 

type PatchPolicyScopeExclusionsIbeacons struct {
	XMLName xml.Name
	Ibeacon *[]IDName `xml:"ibeacon,omitempty"`
}

PatchPolicyScopeExclusionsIbeacons represents a patch policy scope exclusions ibeacons.

func (PatchPolicyScopeExclusionsIbeacons) MarshalXML 

func (t PatchPolicyScopeExclusionsIbeacons) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyScopeExclusionsIbeacons root element name to the wire value declared by the spec (<ibeacons>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyScopeExclusionsNetworkSegments 

type PatchPolicyScopeExclusionsNetworkSegments struct {
	XMLName        xml.Name
	NetworkSegment *[]IDName `xml:"network_segment,omitempty"`
}

PatchPolicyScopeExclusionsNetworkSegments represents a patch policy scope exclusions network segments.

func (PatchPolicyScopeExclusionsNetworkSegments) MarshalXML 

func (t PatchPolicyScopeExclusionsNetworkSegments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyScopeExclusionsNetworkSegments root element name to the wire value declared by the spec (<network_segments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyScopeLimitations 

type PatchPolicyScopeLimitations struct {
	XMLName         xml.Name
	ID              *int                                        `xml:"id,omitempty"`
	Ibeacons        *PatchPolicyScopeLimitationsIbeacons        `xml:"ibeacons,omitempty"`
	NetworkSegments *PatchPolicyScopeLimitationsNetworkSegments `xml:"network_segments,omitempty"`
}

PatchPolicyScopeLimitations represents a patch policy scope limitations.

func (PatchPolicyScopeLimitations) MarshalXML 

func (t PatchPolicyScopeLimitations) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyScopeLimitations root element name to the wire value declared by the spec (<limitations>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyScopeLimitationsIbeacons 

type PatchPolicyScopeLimitationsIbeacons struct {
	XMLName xml.Name
	Ibeacon *[]IDName `xml:"ibeacon,omitempty"`
}

PatchPolicyScopeLimitationsIbeacons represents a patch policy scope limitations ibeacons.

func (PatchPolicyScopeLimitationsIbeacons) MarshalXML 

func (t PatchPolicyScopeLimitationsIbeacons) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyScopeLimitationsIbeacons root element name to the wire value declared by the spec (<ibeacons>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyScopeLimitationsNetworkSegments 

type PatchPolicyScopeLimitationsNetworkSegments struct {
	XMLName        xml.Name
	NetworkSegment *[]IDName `xml:"network_segment,omitempty"`
}

PatchPolicyScopeLimitationsNetworkSegments represents a patch policy scope limitations network segments.

func (PatchPolicyScopeLimitationsNetworkSegments) MarshalXML 

func (t PatchPolicyScopeLimitationsNetworkSegments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyScopeLimitationsNetworkSegments root element name to the wire value declared by the spec (<network_segments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyUserInteraction 

type PatchPolicyUserInteraction struct {
	XMLName                xml.Name
	ID                     *int                                       `xml:"id,omitempty"`
	Deadlines              *PatchPolicyUserInteractionDeadlines       `xml:"deadlines,omitempty"`
	GracePeriod            *PatchPolicyUserInteractionGracePeriod     `xml:"grace_period,omitempty"`
	InstallButtonText      *string                                    `xml:"install_button_text,omitempty"`
	Notifications          *PatchPolicyUserInteractionNotifications   `xml:"notifications,omitempty"`
	SelfServiceDescription *string                                    `xml:"self_service_description,omitempty"`
	SelfServiceIcon        *PatchPolicyUserInteractionSelfServiceIcon `xml:"self_service_icon,omitempty"`
}

PatchPolicyUserInteraction represents a patch policy user interaction.

func (PatchPolicyUserInteraction) MarshalXML 

func (t PatchPolicyUserInteraction) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyUserInteraction root element name to the wire value declared by the spec (<user_interaction>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyUserInteractionDeadlines 

type PatchPolicyUserInteractionDeadlines struct {
	XMLName         xml.Name
	DeadlineEnabled *bool `xml:"deadline_enabled,omitempty"`
	DeadlinePeriod  *int  `xml:"deadline_period,omitempty"`
}

PatchPolicyUserInteractionDeadlines represents a patch policy user interaction deadlines.

func (PatchPolicyUserInteractionDeadlines) MarshalXML 

func (t PatchPolicyUserInteractionDeadlines) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyUserInteractionDeadlines root element name to the wire value declared by the spec (<deadlines>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyUserInteractionGracePeriod 

type PatchPolicyUserInteractionGracePeriod struct {
	XMLName xml.Name
	// Number of minutes to wait before automatically closing all apps required to be closed for an update.
	GracePeriodDuration       *int    `xml:"grace_period_duration,omitempty"`
	Message                   *string `xml:"message,omitempty"`
	NotificationCenterSubject *string `xml:"notification_center_subject,omitempty"`
}

PatchPolicyUserInteractionGracePeriod represents a patch policy user interaction grace period.

func (PatchPolicyUserInteractionGracePeriod) MarshalXML 

func (t PatchPolicyUserInteractionGracePeriod) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyUserInteractionGracePeriod root element name to the wire value declared by the spec (<grace_period>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyUserInteractionNotifications 

type PatchPolicyUserInteractionNotifications struct {
	XMLName             xml.Name
	ID                  *int    `xml:"id,omitempty"`
	NotificationEnabled *bool   `xml:"notification_enabled,omitempty"`
	NotificationMessage *string `xml:"notification_message,omitempty"`
	NotificationSubject *string `xml:"notification_subject,omitempty"`
	// Allowed values: see the PatchPolicyUserInteractionNotificationsNotificationType constants.
	NotificationType *string                                           `xml:"notification_type,omitempty"`
	Reminders        *PatchPolicyUserInteractionNotificationsReminders `xml:"reminders,omitempty"`
}

PatchPolicyUserInteractionNotifications represents a patch policy user interaction notifications.

func (PatchPolicyUserInteractionNotifications) MarshalXML 

func (t PatchPolicyUserInteractionNotifications) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyUserInteractionNotifications root element name to the wire value declared by the spec (<notifications>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyUserInteractionNotificationsNotificationType 

type PatchPolicyUserInteractionNotificationsNotificationType = string

PatchPolicyUserInteractionNotificationsNotificationType is the set of values accepted by PatchPolicyUserInteractionNotifications.NotificationType. 

const (
	PatchPolicyUserInteractionNotificationsNotificationTypeSelfService                      PatchPolicyUserInteractionNotificationsNotificationType = "Self Service"
	PatchPolicyUserInteractionNotificationsNotificationTypeSelfServiceAndNotificationCenter PatchPolicyUserInteractionNotificationsNotificationType = "Self Service and Notification Center"
)

PatchPolicyUserInteractionNotificationsNotificationType 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 PatchPolicyUserInteractionNotificationsNotificationTypeValues 

func PatchPolicyUserInteractionNotificationsNotificationTypeValues() []PatchPolicyUserInteractionNotificationsNotificationType

PatchPolicyUserInteractionNotificationsNotificationTypeValues returns every value the Jamf API accepts for PatchPolicyUserInteractionNotificationsNotificationType, 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 PatchPolicyUserInteractionNotificationsReminders 

type PatchPolicyUserInteractionNotificationsReminders struct {
	XMLName                       xml.Name
	NotificationReminderFrequency *int  `xml:"notification_reminder_frequency,omitempty"`
	NotificationRemindersEnabled  *bool `xml:"notification_reminders_enabled,omitempty"`
}

PatchPolicyUserInteractionNotificationsReminders represents a patch policy user interaction notifications reminders.

func (PatchPolicyUserInteractionNotificationsReminders) MarshalXML 

func (t PatchPolicyUserInteractionNotificationsReminders) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyUserInteractionNotificationsReminders root element name to the wire value declared by the spec (<reminders>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchPolicyUserInteractionSelfServiceIcon 

type PatchPolicyUserInteractionSelfServiceIcon struct {
	XMLName  xml.Name
	Filename *string `xml:"filename,omitempty"`
	ID       *int    `xml:"id,omitempty"`
	URI      *string `xml:"uri,omitempty"`
}

PatchPolicyUserInteractionSelfServiceIcon represents a patch policy user interaction self service icon.

func (PatchPolicyUserInteractionSelfServiceIcon) MarshalXML 

func (t PatchPolicyUserInteractionSelfServiceIcon) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchPolicyUserInteractionSelfServiceIcon root element name to the wire value declared by the spec (<self_service_icon>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchReport 

type PatchReport struct {
	XMLName              xml.Name
	ID                   *int                 `xml:"id,omitempty"`
	Name                 *string              `xml:"name,omitempty"`
	PatchSoftwareTitleID *string              `xml:"patch_software_title_id,omitempty"`
	TotalComputers       *int                 `xml:"total_computers,omitempty"`
	TotalVersions        *int                 `xml:"total_versions,omitempty"`
	Versions             *PatchReportVersions `xml:"versions,omitempty"`
}

PatchReport represents a patch report.

func (PatchReport) MarshalXML 

func (t PatchReport) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchReport root element name to the wire value declared by the spec (<patch_report>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchReportVersions 

type PatchReportVersions struct {
	XMLName xml.Name
	Version *[]PatchReportVersionsVersionItem `xml:"version,omitempty"`
}

PatchReportVersions represents a patch report versions.

func (PatchReportVersions) MarshalXML 

func (t PatchReportVersions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchReportVersions root element name to the wire value declared by the spec (<versions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchReportVersionsVersionItem 

type PatchReportVersionsVersionItem struct {
	XMLName         xml.Name
	ID              *int                                     `xml:"id,omitempty"`
	Computers       *PatchReportVersionsVersionItemComputers `xml:"computers,omitempty"`
	SoftwareVersion *string                                  `xml:"software_version,omitempty"`
}

PatchReportVersionsVersionItem represents a patch report versions version item.

func (PatchReportVersionsVersionItem) MarshalXML 

func (t PatchReportVersionsVersionItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchReportVersionsVersionItem root element name to the wire value declared by the spec (<version>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchReportVersionsVersionItemComputers 

type PatchReportVersionsVersionItemComputers struct {
	XMLName  xml.Name
	Computer *[]PatchReportVersionsVersionItemComputersComputerItem `xml:"computer,omitempty"`
	Size     *int                                                   `xml:"size,omitempty"`
}

PatchReportVersionsVersionItemComputers represents a patch report versions version item computers.

func (PatchReportVersionsVersionItemComputers) MarshalXML 

func (t PatchReportVersionsVersionItemComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchReportVersionsVersionItemComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchReportVersionsVersionItemComputersComputerItem 

type PatchReportVersionsVersionItemComputersComputerItem struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
}

PatchReportVersionsVersionItemComputersComputerItem represents a patch report versions version item computers computer item.

func (PatchReportVersionsVersionItemComputersComputerItem) MarshalXML 

func (t PatchReportVersionsVersionItemComputersComputerItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchReportVersionsVersionItemComputersComputerItem root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchSoftwareTitle 

type PatchSoftwareTitle struct {
	XMLName       xml.Name
	Category      *CategoryObject                  `xml:"category,omitempty"`
	ID            *int                             `xml:"id,omitempty"`
	Name          *string                          `xml:"name,omitempty"`
	NameID        *string                          `xml:"name_id,omitempty"`
	Notifications *PatchSoftwareTitleNotifications `xml:"notifications,omitempty"`
	Site          *SiteObject                      `xml:"site,omitempty"`
	SourceID      *int                             `xml:"source_id,omitempty"`
	Versions      *PatchSoftwareTitleVersions      `xml:"versions,omitempty"`
}

PatchSoftwareTitle represents a patch software title.

func (PatchSoftwareTitle) MarshalXML 

func (t PatchSoftwareTitle) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchSoftwareTitle root element name to the wire value declared by the spec (<patch_software_title>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchSoftwareTitleNotifications 

type PatchSoftwareTitleNotifications struct {
	XMLName           xml.Name
	EmailNotification *bool `xml:"email_notification,omitempty"`
	WebNotification   *bool `xml:"web_notification,omitempty"`
}

PatchSoftwareTitleNotifications represents a patch software title notifications.

func (PatchSoftwareTitleNotifications) MarshalXML 

func (t PatchSoftwareTitleNotifications) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchSoftwareTitleNotifications root element name to the wire value declared by the spec (<notifications>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchSoftwareTitleVersions 

type PatchSoftwareTitleVersions struct {
	XMLName xml.Name
	Version *[]PatchSoftwareTitleVersionsVersionItem `xml:"version,omitempty"`
}

PatchSoftwareTitleVersions represents a patch software title versions.

func (PatchSoftwareTitleVersions) MarshalXML 

func (t PatchSoftwareTitleVersions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchSoftwareTitleVersions root element name to the wire value declared by the spec (<versions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchSoftwareTitleVersionsVersionItem 

type PatchSoftwareTitleVersionsVersionItem struct {
	XMLName         xml.Name
	ID              *int                                          `xml:"id,omitempty"`
	Package         *PatchSoftwareTitleVersionsVersionItemPackage `xml:"package,omitempty"`
	SoftwareVersion *string                                       `xml:"software_version,omitempty"`
}

PatchSoftwareTitleVersionsVersionItem represents a patch software title versions version item.

func (PatchSoftwareTitleVersionsVersionItem) MarshalXML 

func (t PatchSoftwareTitleVersionsVersionItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchSoftwareTitleVersionsVersionItem root element name to the wire value declared by the spec (<version>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchSoftwareTitleVersionsVersionItemPackage 

type PatchSoftwareTitleVersionsVersionItemPackage struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
}

PatchSoftwareTitleVersionsVersionItemPackage represents a patch software title versions version item package.

func (PatchSoftwareTitleVersionsVersionItemPackage) MarshalXML 

func (t PatchSoftwareTitleVersionsVersionItemPackage) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchSoftwareTitleVersionsVersionItemPackage root element name to the wire value declared by the spec (<package>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchSoftwareTitles 

type PatchSoftwareTitles struct {
	XMLName             xml.Name
	Size                *int                                        `xml:"size,omitempty"`
	PatchSoftwareTitles []PatchSoftwareTitlesItemPatchSoftwareTitle `xml:"patch_software_title"`
}

PatchSoftwareTitles wraps a Jamf Classic list response with a flat slice of PatchSoftwareTitlesItemPatchSoftwareTitle.

func (PatchSoftwareTitles) MarshalXML 

func (t PatchSoftwareTitles) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchSoftwareTitles root element name to the wire value declared by the spec (<patch_software_titles>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchSoftwareTitlesItem 

type PatchSoftwareTitlesItem struct {
	XMLName            xml.Name
	ID                 *int                                       `xml:"id,omitempty"`
	PatchSoftwareTitle *PatchSoftwareTitlesItemPatchSoftwareTitle `xml:"patch_software_title,omitempty"`
	Size               *int                                       `xml:"size,omitempty"`
}

PatchSoftwareTitlesItem represents a patch software titles item.

func (PatchSoftwareTitlesItem) MarshalXML 

func (t PatchSoftwareTitlesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchSoftwareTitlesItem root element name to the wire value declared by the spec (<patch_software_title>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PatchSoftwareTitlesItemPatchSoftwareTitle 

type PatchSoftwareTitlesItemPatchSoftwareTitle struct {
	XMLName  xml.Name
	ID       *int    `xml:"id,omitempty"`
	Name     *string `xml:"name,omitempty"`
	NameID   *string `xml:"name_id,omitempty"`
	SourceID *int    `xml:"source_id,omitempty"`
}

PatchSoftwareTitlesItemPatchSoftwareTitle represents a patch software titles item patch software title.

func (PatchSoftwareTitlesItemPatchSoftwareTitle) MarshalXML 

func (t PatchSoftwareTitlesItemPatchSoftwareTitle) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PatchSoftwareTitlesItemPatchSoftwareTitle root element name to the wire value declared by the spec (<patch_software_title>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PayloadsXMLText 

type PayloadsXMLText string

PayloadsXMLText wraps the configuration-profile <payloads> content (raw .mobileconfig plist XML). MarshalXML emits a single CDATA section with every `&` escaped once; UnmarshalXML decodes the server's entity-escaped text form once. The two directions are deliberately asymmetric because the server itself is asymmetric.

The Classic API does not treat <payloads> content per XML 1.0. Wire-verified model (2026-07-30, two Jamf Pro 11.x tenants; full matrix in acc_proclassic_profile_payloads_test.go):

  • Validation: the server entity-decodes the submitted content once and rejects the write with 409 "Unable to update the database" when the result contains a bare `&` or `<`. Spec-correct raw CDATA is therefore rejected for ANY plist containing `&amp;` or `&lt;` — the escape-once form this type emits is the only submittable one for such profiles.
  • Storage is per-payload-type: fragments of types the server re-renders (com.apple.ManagedClient.preferences custom settings — values and dict keys — and com.apple.notificationsettings) are entity-decoded once, so this wire form stores them byte-exact. Fragments of every other payload type (TCC, direct com.apple.loginwindow, all mobiledeviceconfigurationprofiles payloads) are stored verbatim, keeping one extra entity layer — values containing `&`/`<` in those types cannot be stored faithfully by ANY client. Consumers doing read-back comparison (e.g. terraform-provider-jamfplatform) surface that as drift; it is a server defect, not an SDK bug.

Historical note: the 2026-05-27 probes that shipped single-escape element text used a corpus with no `&`/`<` inside <string> values, so the validation 409 went unseen; the 2026-05-26 "double-escape" era (html.EscapeString on top of encoding/xml) corrupted content it could have stored. Both observations are consistent with the model above.

The `]]>` guard keeps the emitted document well-formed (XML 1.0 §2.4/§2.7) when a plist legitimately contains the terminator (embedded CDATA sections). A single CDATA section is used rather than Go's `xml:",cdata"` tag because that tag splits content on `]]>` into multiple sections, which the server's substring-based extractor would truncate.

Note the server canonicalises stored plists regardless of input form: entities for `&` `<` `>`, literals for `"` `'`, sorted keys, and leading/trailing whitespace inside string values is trimmed. Byte-identical round-trips are impossible by design; consumers must compare payloads structurally, never byte-wise.

Line breaks inside string values are their own wire law (wire-verified 2026-08-03, Jamf Pro 11.30.2, both profile endpoints; rendering confirmed on macOS 26.6):

  • Literal LF and TAB are DELETED outright — not collapsed to a space, so the words either side merge — for every payload type the server stores verbatim and for every slot outside the PayloadContent array (e.g. the top-level ConsentText dictionary). MCX custom settings, com.apple.notificationsettings and com.apple.systempolicy.control keep them.
  • CR survives everywhere, which is why this type preserves CR references rather than decoding them, and why Jamf Pro's own UI emits `&#13;` for login-window banner line breaks.
  • U+2028, U+2029 and U+0085 also survive every slot untouched and render as line breaks, so they need no special handling here.

Astral-plane characters (non-BMP, e.g. emoji) are a separate server defect no client can work around: verbatim slots store two U+FFFD replacement characters in their place, and an MCX payload drops its entire mcx_preference_settings dictionary — taking untouched sibling keys with it. macOS itself handles them correctly, so consumers should surface this as a server-side failure rather than retry.

func (PayloadsXMLText) MarshalXML 

func (p PayloadsXMLText) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML emits the plist as a single CDATA section: embedded CDATA sections rewritten as escaped character data, source escaping minimised (see minimizePlistSourceEscaping — avoidable entities become literal text in verbatim-stored values otherwise), any `]]>` entity-guarded, and every `&` escaped once apart from carriage-return references (see escapeAmpPreservingCRRefs). The innerxml field is used because xml.Encoder has no raw-CDATA API. Ordering is load-bearing: CDATA sections must be rewritten before minimising (their content is literal text whose references must NOT be decoded), and the `]]>` guard must follow minimising (decoding `&gt;` can resurrect the terminator).

func (*PayloadsXMLText) UnmarshalXML 

func (p *PayloadsXMLText) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

UnmarshalXML decodes the element's text using encoding/xml's default pass (one level of entity unescape) and stores the result verbatim — correct for GET responses, which the server escapes properly. Not the inverse of MarshalXML: decoding our own marshalled form would return the pre-escaped wire bytes, but the SDK never reads its own writes.

type Policies 

type Policies struct {
	XMLName  xml.Name
	Size     *Size    `xml:"size,omitempty"`
	Policies []IDName `xml:"policy"`
}

Policies wraps a Jamf Classic list response with a flat slice of IDName.

func (Policies) MarshalXML 

func (t Policies) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Policies root element name to the wire value declared by the spec (<policies>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PoliciesItem 

type PoliciesItem struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Policy  *IDName `xml:"policy,omitempty"`
	Size    *Size   `xml:"size,omitempty"`
}

PoliciesItem represents a policies item.

func (PoliciesItem) MarshalXML 

func (t PoliciesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PoliciesItem root element name to the wire value declared by the spec (<policy>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Policy 

type Policy struct {
	XMLName              xml.Name
	ID                   *int                        `xml:"id,omitempty"`
	AccountMaintenance   *PolicyAccountMaintenance   `xml:"account_maintenance,omitempty"`
	DiskEncryption       *PolicyDiskEncryption       `xml:"disk_encryption,omitempty"`
	DockItems            *PolicyDockItems            `xml:"dock_items,omitempty"`
	FilesProcesses       *PolicyFilesProcesses       `xml:"files_processes,omitempty"`
	General              *PolicyGeneral              `xml:"general,omitempty"`
	Maintenance          *PolicyMaintenance          `xml:"maintenance,omitempty"`
	PackageConfiguration *PolicyPackageConfiguration `xml:"package_configuration,omitempty"`
	Printers             *PolicyPrinters             `xml:"printers,omitempty"`
	Reboot               *PolicyReboot               `xml:"reboot,omitempty"`
	Scope                *PolicyScope                `xml:"scope,omitempty"`
	Scripts              *PolicyScripts              `xml:"scripts,omitempty"`
	SelfService          *PolicySelfService          `xml:"self_service,omitempty"`
	UserInteraction      *PolicyUserInteraction      `xml:"user_interaction,omitempty"`
}

Policy represents a policy.

func (Policy) MarshalXML 

func (t Policy) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Policy root element name to the wire value declared by the spec (<policy>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyAccountMaintenance 

type PolicyAccountMaintenance struct {
	XMLName                 xml.Name
	ID                      *int                                             `xml:"id,omitempty"`
	Accounts                *PolicyAccountMaintenanceAccounts                `xml:"accounts,omitempty"`
	DirectoryBindings       *PolicyAccountMaintenanceDirectoryBindings       `xml:"directory_bindings,omitempty"`
	ManagementAccount       *PolicyAccountMaintenanceManagementAccount       `xml:"management_account,omitempty"`
	OpenFirmwareEfiPassword *PolicyAccountMaintenanceOpenFirmwareEfiPassword `xml:"open_firmware_efi_password,omitempty"`
}

PolicyAccountMaintenance represents a policy account maintenance.

func (PolicyAccountMaintenance) MarshalXML 

func (t PolicyAccountMaintenance) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyAccountMaintenance root element name to the wire value declared by the spec (<account_maintenance>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyAccountMaintenanceAccounts 

type PolicyAccountMaintenanceAccounts struct {
	XMLName xml.Name
	Account *[]PolicyAccountMaintenanceAccountsAccountItem `xml:"account,omitempty"`
	Size    *Size                                          `xml:"size,omitempty"`
}

PolicyAccountMaintenanceAccounts represents a policy account maintenance accounts.

func (PolicyAccountMaintenanceAccounts) MarshalXML 

func (t PolicyAccountMaintenanceAccounts) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyAccountMaintenanceAccounts root element name to the wire value declared by the spec (<accounts>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyAccountMaintenanceAccountsAccountItem 

type PolicyAccountMaintenanceAccountsAccountItem struct {
	XMLName xml.Name
	// Allowed values: see the PolicyAccountMaintenanceAccountsAccountItemAction constants.
	Action                 *string `xml:"action,omitempty"`
	Admin                  *bool   `xml:"admin,omitempty"`
	ArchiveHomeDirectory   *bool   `xml:"archive_home_directory,omitempty"`
	ArchiveHomeDirectoryTo *string `xml:"archive_home_directory_to,omitempty"`
	FilevaultEnabled       *bool   `xml:"filevault_enabled,omitempty"`
	Hint                   *string `xml:"hint,omitempty"`
	Home                   *string `xml:"home,omitempty"`
	Password               *string `xml:"password,omitempty"`
	PasswordSha256         *string `xml:"password_sha256,omitempty"`
	Picture                *string `xml:"picture,omitempty"`
	Realname               *string `xml:"realname,omitempty"`
	SecureTokenAllowed     *bool   `xml:"secure_token_allowed,omitempty"`
	Username               *string `xml:"username,omitempty"`
}

PolicyAccountMaintenanceAccountsAccountItem represents a policy account maintenance accounts account item.

func (PolicyAccountMaintenanceAccountsAccountItem) MarshalXML 

func (t PolicyAccountMaintenanceAccountsAccountItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyAccountMaintenanceAccountsAccountItem root element name to the wire value declared by the spec (<account>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyAccountMaintenanceAccountsAccountItemAction 

type PolicyAccountMaintenanceAccountsAccountItemAction = string

PolicyAccountMaintenanceAccountsAccountItemAction is the set of values accepted by PolicyAccountMaintenanceAccountsAccountItem.Action. 

const (
	PolicyAccountMaintenanceAccountsAccountItemActionCreate           PolicyAccountMaintenanceAccountsAccountItemAction = "Create"
	PolicyAccountMaintenanceAccountsAccountItemActionReset            PolicyAccountMaintenanceAccountsAccountItemAction = "Reset"
	PolicyAccountMaintenanceAccountsAccountItemActionDelete           PolicyAccountMaintenanceAccountsAccountItemAction = "Delete"
	PolicyAccountMaintenanceAccountsAccountItemActionDisableFileVault PolicyAccountMaintenanceAccountsAccountItemAction = "DisableFileVault"
)

PolicyAccountMaintenanceAccountsAccountItemAction 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 PolicyAccountMaintenanceAccountsAccountItemActionValues 

func PolicyAccountMaintenanceAccountsAccountItemActionValues() []PolicyAccountMaintenanceAccountsAccountItemAction

PolicyAccountMaintenanceAccountsAccountItemActionValues returns every value the Jamf API accepts for PolicyAccountMaintenanceAccountsAccountItemAction, 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 PolicyAccountMaintenanceDirectoryBindings 

type PolicyAccountMaintenanceDirectoryBindings struct {
	XMLName xml.Name
	Binding *[]IDName `xml:"binding,omitempty"`
	Size    *Size     `xml:"size,omitempty"`
}

PolicyAccountMaintenanceDirectoryBindings represents a policy account maintenance directory bindings.

func (PolicyAccountMaintenanceDirectoryBindings) MarshalXML 

func (t PolicyAccountMaintenanceDirectoryBindings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyAccountMaintenanceDirectoryBindings root element name to the wire value declared by the spec (<directory_bindings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyAccountMaintenanceManagementAccount 

type PolicyAccountMaintenanceManagementAccount struct {
	XMLName xml.Name
	// Allowed values: see the PolicyAccountMaintenanceManagementAccountAction constants.
	Action          *string `xml:"action,omitempty"`
	ManagedPassword *string `xml:"managed_password,omitempty"`
	// Only necessary when utilizing the random action.
	ManagedPasswordLength *int `xml:"managed_password_length,omitempty"`
}

PolicyAccountMaintenanceManagementAccount represents a policy account maintenance management account.

func (PolicyAccountMaintenanceManagementAccount) MarshalXML 

func (t PolicyAccountMaintenanceManagementAccount) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyAccountMaintenanceManagementAccount root element name to the wire value declared by the spec (<management_account>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyAccountMaintenanceManagementAccountAction 

type PolicyAccountMaintenanceManagementAccountAction = string

PolicyAccountMaintenanceManagementAccountAction is the set of values accepted by PolicyAccountMaintenanceManagementAccount.Action. 

const (
	PolicyAccountMaintenanceManagementAccountActionRotate      PolicyAccountMaintenanceManagementAccountAction = "rotate"
	PolicyAccountMaintenanceManagementAccountActionDoNotChange PolicyAccountMaintenanceManagementAccountAction = "doNotChange"
)

PolicyAccountMaintenanceManagementAccountAction 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 PolicyAccountMaintenanceManagementAccountActionValues 

func PolicyAccountMaintenanceManagementAccountActionValues() []PolicyAccountMaintenanceManagementAccountAction

PolicyAccountMaintenanceManagementAccountActionValues returns every value the Jamf API accepts for PolicyAccountMaintenanceManagementAccountAction, 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 PolicyAccountMaintenanceOpenFirmwareEfiPassword 

type PolicyAccountMaintenanceOpenFirmwareEfiPassword struct {
	XMLName xml.Name
	// Allowed values: see the PolicyAccountMaintenanceOpenFirmwareEfiPasswordOfMode constants.
	OfMode           *string `xml:"of_mode,omitempty"`
	OfPassword       *string `xml:"of_password,omitempty"`
	OfPasswordSha256 *string `xml:"of_password_sha256,omitempty"`
}

PolicyAccountMaintenanceOpenFirmwareEfiPassword represents a policy account maintenance open firmware efi password.

func (PolicyAccountMaintenanceOpenFirmwareEfiPassword) MarshalXML 

func (t PolicyAccountMaintenanceOpenFirmwareEfiPassword) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyAccountMaintenanceOpenFirmwareEfiPassword root element name to the wire value declared by the spec (<open_firmware_efi_password>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyAccountMaintenanceOpenFirmwareEfiPasswordOfMode 

type PolicyAccountMaintenanceOpenFirmwareEfiPasswordOfMode = string

PolicyAccountMaintenanceOpenFirmwareEfiPasswordOfMode is the set of values accepted by PolicyAccountMaintenanceOpenFirmwareEfiPassword.OfMode. 

const (
	PolicyAccountMaintenanceOpenFirmwareEfiPasswordOfModeCommand PolicyAccountMaintenanceOpenFirmwareEfiPasswordOfMode = "command"
	PolicyAccountMaintenanceOpenFirmwareEfiPasswordOfModeNone    PolicyAccountMaintenanceOpenFirmwareEfiPasswordOfMode = "none"
)

PolicyAccountMaintenanceOpenFirmwareEfiPasswordOfMode 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 PolicyAccountMaintenanceOpenFirmwareEfiPasswordOfModeValues 

func PolicyAccountMaintenanceOpenFirmwareEfiPasswordOfModeValues() []PolicyAccountMaintenanceOpenFirmwareEfiPasswordOfMode

PolicyAccountMaintenanceOpenFirmwareEfiPasswordOfModeValues returns every value the Jamf API accepts for PolicyAccountMaintenanceOpenFirmwareEfiPasswordOfMode, 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 PolicyDiskEncryption 

type PolicyDiskEncryption struct {
	XMLName xml.Name
	// Allowed values: see the PolicyDiskEncryptionAction constants.
	Action                        *string `xml:"action,omitempty"`
	AuthRestart                   *bool   `xml:"auth_restart,omitempty"`
	DiskEncryptionConfigurationID *int    `xml:"disk_encryption_configuration_id,omitempty"`
	// disk encryption ID to utilize for remediating institutional recovery key types.
	RemediateDiskEncryptionConfigurationID *int `xml:"remediate_disk_encryption_configuration_id,omitempty"`
	// Allowed values: see the PolicyDiskEncryptionRemediateKeyType constants.
	RemediateKeyType *string `xml:"remediate_key_type,omitempty"`
}

PolicyDiskEncryption represents a policy disk encryption.

func (PolicyDiskEncryption) MarshalXML 

func (t PolicyDiskEncryption) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyDiskEncryption root element name to the wire value declared by the spec (<disk_encryption>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyDiskEncryptionAction 

type PolicyDiskEncryptionAction = string

PolicyDiskEncryptionAction is the set of values accepted by PolicyDiskEncryption.Action. 

const (
	PolicyDiskEncryptionActionApply     PolicyDiskEncryptionAction = "apply"
	PolicyDiskEncryptionActionRemediate PolicyDiskEncryptionAction = "remediate"
)

PolicyDiskEncryptionAction 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 PolicyDiskEncryptionActionValues 

func PolicyDiskEncryptionActionValues() []PolicyDiskEncryptionAction

PolicyDiskEncryptionActionValues returns every value the Jamf API accepts for PolicyDiskEncryptionAction, 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 PolicyDiskEncryptionRemediateKeyType 

type PolicyDiskEncryptionRemediateKeyType = string

PolicyDiskEncryptionRemediateKeyType is the set of values accepted by PolicyDiskEncryption.RemediateKeyType. 

const (
	PolicyDiskEncryptionRemediateKeyTypeIndividual                 PolicyDiskEncryptionRemediateKeyType = "Individual"
	PolicyDiskEncryptionRemediateKeyTypeInstitutional              PolicyDiskEncryptionRemediateKeyType = "Institutional"
	PolicyDiskEncryptionRemediateKeyTypeIndividualAndInstitutional PolicyDiskEncryptionRemediateKeyType = "Individual And Institutional"
)

PolicyDiskEncryptionRemediateKeyType 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 PolicyDiskEncryptionRemediateKeyTypeValues 

func PolicyDiskEncryptionRemediateKeyTypeValues() []PolicyDiskEncryptionRemediateKeyType

PolicyDiskEncryptionRemediateKeyTypeValues returns every value the Jamf API accepts for PolicyDiskEncryptionRemediateKeyType, 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 PolicyDockItems 

type PolicyDockItems struct {
	XMLName  xml.Name
	DockItem *[]PolicyDockItemsDockItemItem `xml:"dock_item,omitempty"`
	Size     *Size                          `xml:"size,omitempty"`
}

PolicyDockItems represents a policy dock items.

func (PolicyDockItems) MarshalXML 

func (t PolicyDockItems) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyDockItems root element name to the wire value declared by the spec (<dock_items>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyDockItemsDockItemItem 

type PolicyDockItemsDockItemItem struct {
	XMLName xml.Name
	// Allowed values: see the PolicyDockItemsDockItemItemAction constants.
	Action *string `xml:"action,omitempty"`
	ID     *int    `xml:"id,omitempty"`
	Name   *string `xml:"name,omitempty"`
}

PolicyDockItemsDockItemItem represents a policy dock items dock item item.

func (PolicyDockItemsDockItemItem) MarshalXML 

func (t PolicyDockItemsDockItemItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyDockItemsDockItemItem root element name to the wire value declared by the spec (<dock_item>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyDockItemsDockItemItemAction 

type PolicyDockItemsDockItemItemAction = string

PolicyDockItemsDockItemItemAction is the set of values accepted by PolicyDockItemsDockItemItem.Action. 

const (
	PolicyDockItemsDockItemItemActionAddToBeginning PolicyDockItemsDockItemItemAction = "Add To Beginning"
	PolicyDockItemsDockItemItemActionAddToEnd       PolicyDockItemsDockItemItemAction = "Add To End"
	PolicyDockItemsDockItemItemActionRemove         PolicyDockItemsDockItemItemAction = "Remove"
)

PolicyDockItemsDockItemItemAction 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 PolicyDockItemsDockItemItemActionValues 

func PolicyDockItemsDockItemItemActionValues() []PolicyDockItemsDockItemItemAction

PolicyDockItemsDockItemItemActionValues returns every value the Jamf API accepts for PolicyDockItemsDockItemItemAction, 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 PolicyFilesProcesses 

type PolicyFilesProcesses struct {
	XMLName              xml.Name
	DeleteFile           *bool   `xml:"delete_file,omitempty"`
	KillProcess          *bool   `xml:"kill_process,omitempty"`
	LocateFile           *string `xml:"locate_file,omitempty"`
	RunCommand           *string `xml:"run_command,omitempty"`
	SearchByPath         *string `xml:"search_by_path,omitempty"`
	SearchForProcess     *string `xml:"search_for_process,omitempty"`
	SpotlightSearch      *string `xml:"spotlight_search,omitempty"`
	UpdateLocateDatabase *bool   `xml:"update_locate_database,omitempty"`
}

PolicyFilesProcesses represents a policy files processes.

func (PolicyFilesProcesses) MarshalXML 

func (t PolicyFilesProcesses) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyFilesProcesses root element name to the wire value declared by the spec (<files_processes>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyGeneral 

type PolicyGeneral struct {
	XMLName             xml.Name
	Category            *CategoryObject                   `xml:"category,omitempty"`
	DateTimeLimitations *PolicyGeneralDateTimeLimitations `xml:"date_time_limitations,omitempty"`
	Enabled             *bool                             `xml:"enabled,omitempty"`
	// Allowed values: see the PolicyGeneralFrequency constants.
	Frequency          *string                          `xml:"frequency,omitempty"`
	ID                 *int                             `xml:"id,omitempty"`
	LocationUserOnly   *bool                            `xml:"location_user_only,omitempty"`
	Name               *string                          `xml:"name,omitempty"`
	NetworkLimitations *PolicyGeneralNetworkLimitations `xml:"network_limitations,omitempty"`
	// Allowed values: see the PolicyGeneralNetworkRequirements constants.
	NetworkRequirements     *string                               `xml:"network_requirements,omitempty"`
	NotifyOnEachFailedRetry *bool                                 `xml:"notify_on_each_failed_retry,omitempty"`
	Offline                 *bool                                 `xml:"offline,omitempty"`
	OverrideDefaultSettings *PolicyGeneralOverrideDefaultSettings `xml:"override_default_settings,omitempty"`
	RetryAttempts           *int                                  `xml:"retry_attempts,omitempty"`
	// Allowed values: see the PolicyGeneralRetryEvent constants.
	RetryEvent                 *string     `xml:"retry_event,omitempty"`
	Site                       *SiteObject `xml:"site,omitempty"`
	TargetDrive                *string     `xml:"target_drive,omitempty"`
	Trigger                    *string     `xml:"trigger,omitempty"`
	TriggerCheckin             *bool       `xml:"trigger_checkin,omitempty"`
	TriggerEnrollmentComplete  *bool       `xml:"trigger_enrollment_complete,omitempty"`
	TriggerLogin               *bool       `xml:"trigger_login,omitempty"`
	TriggerLogout              *bool       `xml:"trigger_logout,omitempty"`
	TriggerNetworkStateChanged *bool       `xml:"trigger_network_state_changed,omitempty"`
	TriggerOther               *string     `xml:"trigger_other,omitempty"`
	TriggerStartup             *bool       `xml:"trigger_startup,omitempty"`
}

PolicyGeneral represents a policy general.

func (PolicyGeneral) MarshalXML 

func (t PolicyGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyGeneralDateTimeLimitations 

type PolicyGeneralDateTimeLimitations struct {
	XMLName             xml.Name
	ID                  *int                                         `xml:"id,omitempty"`
	ActivationDate      *string                                      `xml:"activation_date,omitempty"`
	ActivationDateEpoch *int                                         `xml:"activation_date_epoch,omitempty"`
	ActivationDateUtc   *string                                      `xml:"activation_date_utc,omitempty"`
	ExpirationDate      *string                                      `xml:"expiration_date,omitempty"`
	ExpirationDateEpoch *BigInt                                      `xml:"expiration_date_epoch"`
	ExpirationDateUtc   *string                                      `xml:"expiration_date_utc,omitempty"`
	NoExecuteEnd        *string                                      `xml:"no_execute_end,omitempty"`
	NoExecuteOn         *PolicyGeneralDateTimeLimitationsNoExecuteOn `xml:"no_execute_on,omitempty"`
	NoExecuteStart      *string                                      `xml:"no_execute_start,omitempty"`
}

PolicyGeneralDateTimeLimitations represents a policy general date time limitations.

func (PolicyGeneralDateTimeLimitations) MarshalXML 

func (t PolicyGeneralDateTimeLimitations) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyGeneralDateTimeLimitations root element name to the wire value declared by the spec (<date_time_limitations>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyGeneralDateTimeLimitationsNoExecuteOn 

type PolicyGeneralDateTimeLimitationsNoExecuteOn struct {
	XMLName xml.Name
	// Allowed values: see the PolicyGeneralDateTimeLimitationsNoExecuteOnDay constants.
	Day *[]string `xml:"day,omitempty"`
}

PolicyGeneralDateTimeLimitationsNoExecuteOn represents a policy general date time limitations no execute on.

func (PolicyGeneralDateTimeLimitationsNoExecuteOn) MarshalXML 

func (t PolicyGeneralDateTimeLimitationsNoExecuteOn) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyGeneralDateTimeLimitationsNoExecuteOn root element name to the wire value declared by the spec (<no_execute_on>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyGeneralDateTimeLimitationsNoExecuteOnDay 

type PolicyGeneralDateTimeLimitationsNoExecuteOnDay = string

PolicyGeneralDateTimeLimitationsNoExecuteOnDay is the set of values accepted by PolicyGeneralDateTimeLimitationsNoExecuteOn.Day. 

const (
	PolicyGeneralDateTimeLimitationsNoExecuteOnDaySun PolicyGeneralDateTimeLimitationsNoExecuteOnDay = "Sun"
	PolicyGeneralDateTimeLimitationsNoExecuteOnDayMon PolicyGeneralDateTimeLimitationsNoExecuteOnDay = "Mon"
	PolicyGeneralDateTimeLimitationsNoExecuteOnDayTue PolicyGeneralDateTimeLimitationsNoExecuteOnDay = "Tue"
	PolicyGeneralDateTimeLimitationsNoExecuteOnDayWed PolicyGeneralDateTimeLimitationsNoExecuteOnDay = "Wed"
	PolicyGeneralDateTimeLimitationsNoExecuteOnDayThu PolicyGeneralDateTimeLimitationsNoExecuteOnDay = "Thu"
	PolicyGeneralDateTimeLimitationsNoExecuteOnDayFri PolicyGeneralDateTimeLimitationsNoExecuteOnDay = "Fri"
	PolicyGeneralDateTimeLimitationsNoExecuteOnDaySat PolicyGeneralDateTimeLimitationsNoExecuteOnDay = "Sat"
)

PolicyGeneralDateTimeLimitationsNoExecuteOnDay 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 PolicyGeneralDateTimeLimitationsNoExecuteOnDayValues 

func PolicyGeneralDateTimeLimitationsNoExecuteOnDayValues() []PolicyGeneralDateTimeLimitationsNoExecuteOnDay

PolicyGeneralDateTimeLimitationsNoExecuteOnDayValues returns every value the Jamf API accepts for PolicyGeneralDateTimeLimitationsNoExecuteOnDay, 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 PolicyGeneralFrequency 

type PolicyGeneralFrequency = string

PolicyGeneralFrequency is the set of values accepted by PolicyGeneral.Frequency. 

const (
	PolicyGeneralFrequencyOncePerComputer        PolicyGeneralFrequency = "Once per computer"
	PolicyGeneralFrequencyOncePerUserPerComputer PolicyGeneralFrequency = "Once per user per computer"
	PolicyGeneralFrequencyOncePerUser            PolicyGeneralFrequency = "Once per user"
	PolicyGeneralFrequencyOnceEveryDay           PolicyGeneralFrequency = "Once every day"
	PolicyGeneralFrequencyOnceEveryWeek          PolicyGeneralFrequency = "Once every week"
	PolicyGeneralFrequencyOnceEveryMonth         PolicyGeneralFrequency = "Once every month"
	PolicyGeneralFrequencyOngoing                PolicyGeneralFrequency = "Ongoing"
)

PolicyGeneralFrequency 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 PolicyGeneralFrequencyValues 

func PolicyGeneralFrequencyValues() []PolicyGeneralFrequency

PolicyGeneralFrequencyValues returns every value the Jamf API accepts for PolicyGeneralFrequency, 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 PolicyGeneralNetworkLimitations 

type PolicyGeneralNetworkLimitations struct {
	XMLName      xml.Name
	ID           *int  `xml:"id,omitempty"`
	AnyIPAddress *bool `xml:"any_ip_address,omitempty"`
	// Allowed values: see the PolicyGeneralNetworkLimitationsMinimumNetworkConnection constants.
	MinimumNetworkConnection *string                                         `xml:"minimum_network_connection,omitempty"`
	NetworkSegments          *PolicyGeneralNetworkLimitationsNetworkSegments `xml:"network_segments,omitempty"`
}

PolicyGeneralNetworkLimitations represents a policy general network limitations.

func (PolicyGeneralNetworkLimitations) MarshalXML 

func (t PolicyGeneralNetworkLimitations) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyGeneralNetworkLimitations root element name to the wire value declared by the spec (<network_limitations>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyGeneralNetworkLimitationsMinimumNetworkConnection 

type PolicyGeneralNetworkLimitationsMinimumNetworkConnection = string

PolicyGeneralNetworkLimitationsMinimumNetworkConnection is the set of values accepted by PolicyGeneralNetworkLimitations.MinimumNetworkConnection. 

const (
	PolicyGeneralNetworkLimitationsMinimumNetworkConnectionNoMinimum PolicyGeneralNetworkLimitationsMinimumNetworkConnection = "No Minimum"
	PolicyGeneralNetworkLimitationsMinimumNetworkConnectionEthernet  PolicyGeneralNetworkLimitationsMinimumNetworkConnection = "Ethernet"
)

PolicyGeneralNetworkLimitationsMinimumNetworkConnection 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 PolicyGeneralNetworkLimitationsMinimumNetworkConnectionValues 

func PolicyGeneralNetworkLimitationsMinimumNetworkConnectionValues() []PolicyGeneralNetworkLimitationsMinimumNetworkConnection

PolicyGeneralNetworkLimitationsMinimumNetworkConnectionValues returns every value the Jamf API accepts for PolicyGeneralNetworkLimitationsMinimumNetworkConnection, 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 PolicyGeneralNetworkLimitationsNetworkSegments 

type PolicyGeneralNetworkLimitationsNetworkSegments struct {
	XMLName        xml.Name
	NetworkSegment *[]IDName `xml:"network_segment,omitempty"`
}

PolicyGeneralNetworkLimitationsNetworkSegments represents a policy general network limitations network segments.

func (PolicyGeneralNetworkLimitationsNetworkSegments) MarshalXML 

func (t PolicyGeneralNetworkLimitationsNetworkSegments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyGeneralNetworkLimitationsNetworkSegments root element name to the wire value declared by the spec (<network_segments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyGeneralNetworkRequirements 

type PolicyGeneralNetworkRequirements = string

PolicyGeneralNetworkRequirements is the set of values accepted by PolicyGeneral.NetworkRequirements. 

const (
	PolicyGeneralNetworkRequirementsAny      PolicyGeneralNetworkRequirements = "Any"
	PolicyGeneralNetworkRequirementsEthernet PolicyGeneralNetworkRequirements = "Ethernet"
)

PolicyGeneralNetworkRequirements 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 PolicyGeneralNetworkRequirementsValues 

func PolicyGeneralNetworkRequirementsValues() []PolicyGeneralNetworkRequirements

PolicyGeneralNetworkRequirementsValues returns every value the Jamf API accepts for PolicyGeneralNetworkRequirements, 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 PolicyGeneralOverrideDefaultSettings 

type PolicyGeneralOverrideDefaultSettings struct {
	XMLName           xml.Name
	DistributionPoint *string `xml:"distribution_point,omitempty"`
	ForceAfpSmb       *bool   `xml:"force_afp_smb,omitempty"`
	Sus               *string `xml:"sus,omitempty"`
	TargetDrive       *string `xml:"target_drive,omitempty"`
}

PolicyGeneralOverrideDefaultSettings represents a policy general override default settings.

func (PolicyGeneralOverrideDefaultSettings) MarshalXML 

func (t PolicyGeneralOverrideDefaultSettings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyGeneralOverrideDefaultSettings root element name to the wire value declared by the spec (<override_default_settings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyGeneralRetryEvent 

type PolicyGeneralRetryEvent = string

PolicyGeneralRetryEvent is the set of values accepted by PolicyGeneral.RetryEvent. 

const (
	PolicyGeneralRetryEventNone    PolicyGeneralRetryEvent = "none"
	PolicyGeneralRetryEventTrigger PolicyGeneralRetryEvent = "trigger"
	PolicyGeneralRetryEventCheckIn PolicyGeneralRetryEvent = "check-in"
)

PolicyGeneralRetryEvent 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 PolicyGeneralRetryEventValues 

func PolicyGeneralRetryEventValues() []PolicyGeneralRetryEvent

PolicyGeneralRetryEventValues returns every value the Jamf API accepts for PolicyGeneralRetryEvent, 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 PolicyMaintenance 

type PolicyMaintenance struct {
	XMLName                  xml.Name
	Byhost                   *bool `xml:"byhost,omitempty"`
	Heal                     *bool `xml:"heal,omitempty"`
	InstallAllCachedPackages *bool `xml:"install_all_cached_packages,omitempty"`
	Permissions              *bool `xml:"permissions,omitempty"`
	Prebindings              *bool `xml:"prebindings,omitempty"`
	Recon                    *bool `xml:"recon,omitempty"`
	ResetName                *bool `xml:"reset_name,omitempty"`
	SystemCache              *bool `xml:"system_cache,omitempty"`
	UserCache                *bool `xml:"user_cache,omitempty"`
	Verify                   *bool `xml:"verify,omitempty"`
}

PolicyMaintenance represents a policy maintenance.

func (PolicyMaintenance) MarshalXML 

func (t PolicyMaintenance) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyMaintenance root element name to the wire value declared by the spec (<maintenance>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPackageConfiguration 

type PolicyPackageConfiguration struct {
	XMLName           xml.Name
	ID                *int                                `xml:"id,omitempty"`
	DistributionPoint *string                             `xml:"distribution_point,omitempty"`
	Packages          *PolicyPackageConfigurationPackages `xml:"packages,omitempty"`
}

PolicyPackageConfiguration represents a policy package configuration.

func (PolicyPackageConfiguration) MarshalXML 

func (t PolicyPackageConfiguration) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyPackageConfiguration root element name to the wire value declared by the spec (<package_configuration>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPackageConfigurationPackages 

type PolicyPackageConfigurationPackages struct {
	XMLName xml.Name
	Package *[]PolicyPackageConfigurationPackagesPackageItem `xml:"package,omitempty"`
	Size    *Size                                            `xml:"size,omitempty"`
}

PolicyPackageConfigurationPackages represents a policy package configuration packages.

func (PolicyPackageConfigurationPackages) MarshalXML 

func (t PolicyPackageConfigurationPackages) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyPackageConfigurationPackages root element name to the wire value declared by the spec (<packages>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPackageConfigurationPackagesPackageItem 

type PolicyPackageConfigurationPackagesPackageItem struct {
	XMLName xml.Name
	// Allowed values: see the PolicyPackageConfigurationPackagesPackageItemAction constants.
	Action        *string `xml:"action,omitempty"`
	Feu           *bool   `xml:"feu,omitempty"`
	Fut           *bool   `xml:"fut,omitempty"`
	ID            *int    `xml:"id,omitempty"`
	Name          *string `xml:"name,omitempty"`
	UpdateAutorun *bool   `xml:"update_autorun,omitempty"`
}

PolicyPackageConfigurationPackagesPackageItem represents a policy package configuration packages package item.

func (PolicyPackageConfigurationPackagesPackageItem) MarshalXML 

func (t PolicyPackageConfigurationPackagesPackageItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyPackageConfigurationPackagesPackageItem root element name to the wire value declared by the spec (<package>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPackageConfigurationPackagesPackageItemAction 

type PolicyPackageConfigurationPackagesPackageItemAction = string

PolicyPackageConfigurationPackagesPackageItemAction is the set of values accepted by PolicyPackageConfigurationPackagesPackageItem.Action. 

const (
	PolicyPackageConfigurationPackagesPackageItemActionInstall       PolicyPackageConfigurationPackagesPackageItemAction = "Install"
	PolicyPackageConfigurationPackagesPackageItemActionCache         PolicyPackageConfigurationPackagesPackageItemAction = "Cache"
	PolicyPackageConfigurationPackagesPackageItemActionInstallCached PolicyPackageConfigurationPackagesPackageItemAction = "Install Cached"
)

PolicyPackageConfigurationPackagesPackageItemAction 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 PolicyPackageConfigurationPackagesPackageItemActionValues 

func PolicyPackageConfigurationPackagesPackageItemActionValues() []PolicyPackageConfigurationPackagesPackageItemAction

PolicyPackageConfigurationPackagesPackageItemActionValues returns every value the Jamf API accepts for PolicyPackageConfigurationPackagesPackageItemAction, 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 PolicyPost 

type PolicyPost struct {
	XMLName              xml.Name
	ID                   *int                            `xml:"id,omitempty"`
	AccountMaintenance   *PolicyPostAccountMaintenance   `xml:"account_maintenance,omitempty"`
	DiskEncryption       *PolicyPostDiskEncryption       `xml:"disk_encryption,omitempty"`
	DockItems            *PolicyPostDockItems            `xml:"dock_items,omitempty"`
	FilesProcesses       *PolicyPostFilesProcesses       `xml:"files_processes,omitempty"`
	General              *PolicyPostGeneral              `xml:"general,omitempty"`
	Maintenance          *PolicyPostMaintenance          `xml:"maintenance,omitempty"`
	PackageConfiguration *PolicyPostPackageConfiguration `xml:"package_configuration,omitempty"`
	Printers             *PolicyPostPrinters             `xml:"printers,omitempty"`
	Reboot               *PolicyPostReboot               `xml:"reboot,omitempty"`
	Scope                *PolicyPostScope                `xml:"scope,omitempty"`
	Scripts              *PolicyPostScripts              `xml:"scripts,omitempty"`
	SelfService          *PolicyPostSelfService          `xml:"self_service,omitempty"`
	UserInteraction      *PolicyPostUserInteraction      `xml:"user_interaction,omitempty"`
}

PolicyPost represents a policy post.

func (PolicyPost) MarshalXML 

func (t PolicyPost) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyPost root element name to the wire value declared by the spec (<policy>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPostAccountMaintenance 

type PolicyPostAccountMaintenance struct {
	XMLName                 xml.Name
	ID                      *int                                             `xml:"id,omitempty"`
	Accounts                *PolicyAccountMaintenanceAccounts                `xml:"accounts,omitempty"`
	DirectoryBindings       *PolicyAccountMaintenanceDirectoryBindings       `xml:"directory_bindings,omitempty"`
	ManagementAccount       *PolicyAccountMaintenanceManagementAccount       `xml:"management_account,omitempty"`
	OpenFirmwareEfiPassword *PolicyAccountMaintenanceOpenFirmwareEfiPassword `xml:"open_firmware_efi_password,omitempty"`
}

PolicyPostAccountMaintenance represents a policy post account maintenance.

func (PolicyPostAccountMaintenance) MarshalXML 

func (t PolicyPostAccountMaintenance) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyPostAccountMaintenance root element name to the wire value declared by the spec (<account_maintenance>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPostDiskEncryption 

type PolicyPostDiskEncryption struct {
	XMLName xml.Name
	// Allowed values: see the PolicyPostDiskEncryptionAction constants.
	Action                        *string `xml:"action,omitempty"`
	AuthRestart                   *bool   `xml:"auth_restart,omitempty"`
	DiskEncryptionConfigurationID *int    `xml:"disk_encryption_configuration_id,omitempty"`
	// disk encryption ID to utilize for remediating institutional recovery key types.
	RemediateDiskEncryptionConfigurationID *int `xml:"remediate_disk_encryption_configuration_id,omitempty"`
	// Allowed values: see the PolicyPostDiskEncryptionRemediateKeyType constants.
	RemediateKeyType *string `xml:"remediate_key_type,omitempty"`
}

PolicyPostDiskEncryption represents a policy post disk encryption.

func (PolicyPostDiskEncryption) MarshalXML 

func (t PolicyPostDiskEncryption) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyPostDiskEncryption root element name to the wire value declared by the spec (<disk_encryption>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPostDiskEncryptionAction 

type PolicyPostDiskEncryptionAction = string

PolicyPostDiskEncryptionAction is the set of values accepted by PolicyPostDiskEncryption.Action. 

const (
	PolicyPostDiskEncryptionActionApply     PolicyPostDiskEncryptionAction = "apply"
	PolicyPostDiskEncryptionActionRemediate PolicyPostDiskEncryptionAction = "remediate"
)

PolicyPostDiskEncryptionAction 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 PolicyPostDiskEncryptionActionValues 

func PolicyPostDiskEncryptionActionValues() []PolicyPostDiskEncryptionAction

PolicyPostDiskEncryptionActionValues returns every value the Jamf API accepts for PolicyPostDiskEncryptionAction, 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 PolicyPostDiskEncryptionRemediateKeyType 

type PolicyPostDiskEncryptionRemediateKeyType = string

PolicyPostDiskEncryptionRemediateKeyType is the set of values accepted by PolicyPostDiskEncryption.RemediateKeyType. 

const (
	PolicyPostDiskEncryptionRemediateKeyTypeIndividual                 PolicyPostDiskEncryptionRemediateKeyType = "Individual"
	PolicyPostDiskEncryptionRemediateKeyTypeInstitutional              PolicyPostDiskEncryptionRemediateKeyType = "Institutional"
	PolicyPostDiskEncryptionRemediateKeyTypeIndividualAndInstitutional PolicyPostDiskEncryptionRemediateKeyType = "Individual And Institutional"
)

PolicyPostDiskEncryptionRemediateKeyType 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 PolicyPostDiskEncryptionRemediateKeyTypeValues 

func PolicyPostDiskEncryptionRemediateKeyTypeValues() []PolicyPostDiskEncryptionRemediateKeyType

PolicyPostDiskEncryptionRemediateKeyTypeValues returns every value the Jamf API accepts for PolicyPostDiskEncryptionRemediateKeyType, 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 PolicyPostDockItems 

type PolicyPostDockItems struct {
	XMLName  xml.Name
	DockItem *[]PolicyPostDockItemsDockItemItem `xml:"dock_item,omitempty"`
	Size     *Size                              `xml:"size,omitempty"`
}

PolicyPostDockItems represents a policy post dock items.

func (PolicyPostDockItems) MarshalXML 

func (t PolicyPostDockItems) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyPostDockItems root element name to the wire value declared by the spec (<dock_items>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPostDockItemsDockItemItem 

type PolicyPostDockItemsDockItemItem struct {
	XMLName xml.Name
	// Allowed values: see the PolicyPostDockItemsDockItemItemAction constants.
	Action *string `xml:"action,omitempty"`
	ID     *int    `xml:"id,omitempty"`
	Name   *string `xml:"name,omitempty"`
}

PolicyPostDockItemsDockItemItem represents a policy post dock items dock item item.

func (PolicyPostDockItemsDockItemItem) MarshalXML 

func (t PolicyPostDockItemsDockItemItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyPostDockItemsDockItemItem root element name to the wire value declared by the spec (<dock_item>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPostDockItemsDockItemItemAction 

type PolicyPostDockItemsDockItemItemAction = string

PolicyPostDockItemsDockItemItemAction is the set of values accepted by PolicyPostDockItemsDockItemItem.Action. 

const (
	PolicyPostDockItemsDockItemItemActionAddToBeginning PolicyPostDockItemsDockItemItemAction = "Add To Beginning"
	PolicyPostDockItemsDockItemItemActionAddToEnd       PolicyPostDockItemsDockItemItemAction = "Add To End"
	PolicyPostDockItemsDockItemItemActionRemove         PolicyPostDockItemsDockItemItemAction = "Remove"
)

PolicyPostDockItemsDockItemItemAction 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 PolicyPostDockItemsDockItemItemActionValues 

func PolicyPostDockItemsDockItemItemActionValues() []PolicyPostDockItemsDockItemItemAction

PolicyPostDockItemsDockItemItemActionValues returns every value the Jamf API accepts for PolicyPostDockItemsDockItemItemAction, 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 PolicyPostFilesProcesses 

type PolicyPostFilesProcesses struct {
	XMLName              xml.Name
	DeleteFile           *bool   `xml:"delete_file,omitempty"`
	KillProcess          *bool   `xml:"kill_process,omitempty"`
	LocateFile           *string `xml:"locate_file,omitempty"`
	RunCommand           *string `xml:"run_command,omitempty"`
	SearchByPath         *string `xml:"search_by_path,omitempty"`
	SearchForProcess     *string `xml:"search_for_process,omitempty"`
	SpotlightSearch      *string `xml:"spotlight_search,omitempty"`
	UpdateLocateDatabase *bool   `xml:"update_locate_database,omitempty"`
}

PolicyPostFilesProcesses represents a policy post files processes.

func (PolicyPostFilesProcesses) MarshalXML 

func (t PolicyPostFilesProcesses) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyPostFilesProcesses root element name to the wire value declared by the spec (<files_processes>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPostGeneral 

type PolicyPostGeneral struct {
	XMLName             xml.Name
	Category            *CategoryObject                   `xml:"category,omitempty"`
	DateTimeLimitations *PolicyGeneralDateTimeLimitations `xml:"date_time_limitations,omitempty"`
	Enabled             *bool                             `xml:"enabled,omitempty"`
	// Allowed values: see the PolicyPostGeneralFrequency constants.
	Frequency          *string                          `xml:"frequency,omitempty"`
	ID                 *int                             `xml:"id,omitempty"`
	LocationUserOnly   *bool                            `xml:"location_user_only,omitempty"`
	Name               *string                          `xml:"name,omitempty"`
	NetworkLimitations *PolicyGeneralNetworkLimitations `xml:"network_limitations,omitempty"`
	// Allowed values: see the PolicyPostGeneralNetworkRequirements constants.
	NetworkRequirements     *string                               `xml:"network_requirements,omitempty"`
	NotifyOnEachFailedRetry *bool                                 `xml:"notify_on_each_failed_retry,omitempty"`
	Offline                 *bool                                 `xml:"offline,omitempty"`
	OverrideDefaultSettings *PolicyGeneralOverrideDefaultSettings `xml:"override_default_settings,omitempty"`
	RetryAttempts           *int                                  `xml:"retry_attempts,omitempty"`
	// Allowed values: see the PolicyPostGeneralRetryEvent constants.
	RetryEvent                 *string     `xml:"retry_event,omitempty"`
	Site                       *SiteObject `xml:"site,omitempty"`
	TargetDrive                *string     `xml:"target_drive,omitempty"`
	Trigger                    *string     `xml:"trigger,omitempty"`
	TriggerCheckin             *bool       `xml:"trigger_checkin,omitempty"`
	TriggerEnrollmentComplete  *bool       `xml:"trigger_enrollment_complete,omitempty"`
	TriggerLogin               *bool       `xml:"trigger_login,omitempty"`
	TriggerLogout              *bool       `xml:"trigger_logout,omitempty"`
	TriggerNetworkStateChanged *bool       `xml:"trigger_network_state_changed,omitempty"`
	TriggerOther               *string     `xml:"trigger_other,omitempty"`
	TriggerStartup             *bool       `xml:"trigger_startup,omitempty"`
}

PolicyPostGeneral represents a policy post general.

func (PolicyPostGeneral) MarshalXML 

func (t PolicyPostGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyPostGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPostGeneralFrequency 

type PolicyPostGeneralFrequency = string

PolicyPostGeneralFrequency is the set of values accepted by PolicyPostGeneral.Frequency. 

const (
	PolicyPostGeneralFrequencyOncePerComputer        PolicyPostGeneralFrequency = "Once per computer"
	PolicyPostGeneralFrequencyOncePerUserPerComputer PolicyPostGeneralFrequency = "Once per user per computer"
	PolicyPostGeneralFrequencyOncePerUser            PolicyPostGeneralFrequency = "Once per user"
	PolicyPostGeneralFrequencyOnceEveryDay           PolicyPostGeneralFrequency = "Once every day"
	PolicyPostGeneralFrequencyOnceEveryWeek          PolicyPostGeneralFrequency = "Once every week"
	PolicyPostGeneralFrequencyOnceEveryMonth         PolicyPostGeneralFrequency = "Once every month"
	PolicyPostGeneralFrequencyOngoing                PolicyPostGeneralFrequency = "Ongoing"
)

PolicyPostGeneralFrequency 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 PolicyPostGeneralFrequencyValues 

func PolicyPostGeneralFrequencyValues() []PolicyPostGeneralFrequency

PolicyPostGeneralFrequencyValues returns every value the Jamf API accepts for PolicyPostGeneralFrequency, 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 PolicyPostGeneralNetworkRequirements 

type PolicyPostGeneralNetworkRequirements = string

PolicyPostGeneralNetworkRequirements is the set of values accepted by PolicyPostGeneral.NetworkRequirements. 

const (
	PolicyPostGeneralNetworkRequirementsAny      PolicyPostGeneralNetworkRequirements = "Any"
	PolicyPostGeneralNetworkRequirementsEthernet PolicyPostGeneralNetworkRequirements = "Ethernet"
)

PolicyPostGeneralNetworkRequirements 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 PolicyPostGeneralNetworkRequirementsValues 

func PolicyPostGeneralNetworkRequirementsValues() []PolicyPostGeneralNetworkRequirements

PolicyPostGeneralNetworkRequirementsValues returns every value the Jamf API accepts for PolicyPostGeneralNetworkRequirements, 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 PolicyPostGeneralRetryEvent 

type PolicyPostGeneralRetryEvent = string

PolicyPostGeneralRetryEvent is the set of values accepted by PolicyPostGeneral.RetryEvent. 

const (
	PolicyPostGeneralRetryEventNone    PolicyPostGeneralRetryEvent = "none"
	PolicyPostGeneralRetryEventTrigger PolicyPostGeneralRetryEvent = "trigger"
	PolicyPostGeneralRetryEventCheckIn PolicyPostGeneralRetryEvent = "check-in"
)

PolicyPostGeneralRetryEvent 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 PolicyPostGeneralRetryEventValues 

func PolicyPostGeneralRetryEventValues() []PolicyPostGeneralRetryEvent

PolicyPostGeneralRetryEventValues returns every value the Jamf API accepts for PolicyPostGeneralRetryEvent, 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 PolicyPostMaintenance 

type PolicyPostMaintenance struct {
	XMLName                  xml.Name
	Byhost                   *bool `xml:"byhost,omitempty"`
	Heal                     *bool `xml:"heal,omitempty"`
	InstallAllCachedPackages *bool `xml:"install_all_cached_packages,omitempty"`
	Permissions              *bool `xml:"permissions,omitempty"`
	Prebindings              *bool `xml:"prebindings,omitempty"`
	Recon                    *bool `xml:"recon,omitempty"`
	ResetName                *bool `xml:"reset_name,omitempty"`
	SystemCache              *bool `xml:"system_cache,omitempty"`
	UserCache                *bool `xml:"user_cache,omitempty"`
	Verify                   *bool `xml:"verify,omitempty"`
}

PolicyPostMaintenance represents a policy post maintenance.

func (PolicyPostMaintenance) MarshalXML 

func (t PolicyPostMaintenance) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyPostMaintenance root element name to the wire value declared by the spec (<maintenance>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPostPackageConfiguration 

type PolicyPostPackageConfiguration struct {
	XMLName           xml.Name
	ID                *int                                `xml:"id,omitempty"`
	DistributionPoint *string                             `xml:"distribution_point,omitempty"`
	Packages          *PolicyPackageConfigurationPackages `xml:"packages,omitempty"`
}

PolicyPostPackageConfiguration represents a policy post package configuration.

func (PolicyPostPackageConfiguration) MarshalXML 

func (t PolicyPostPackageConfiguration) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyPostPackageConfiguration root element name to the wire value declared by the spec (<package_configuration>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPostPrinters 

type PolicyPostPrinters struct {
	XMLName              xml.Name
	LeaveExistingDefault *bool                        `xml:"leave_existing_default,omitempty"`
	Printer              *[]PolicyPrintersPrinterItem `xml:"printer,omitempty"`
	Size                 *int                         `xml:"size,omitempty"`
}

PolicyPostPrinters represents a policy post printers.

func (PolicyPostPrinters) MarshalXML 

func (t PolicyPostPrinters) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyPostPrinters root element name to the wire value declared by the spec (<printers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPostReboot 

type PolicyPostReboot struct {
	XMLName                     xml.Name
	FileVault2Reboot            *bool   `xml:"file_vault_2_reboot,omitempty"`
	Message                     *string `xml:"message,omitempty"`
	MinutesUntilReboot          *int    `xml:"minutes_until_reboot,omitempty"`
	NoUserLoggedIn              *string `xml:"no_user_logged_in,omitempty"`
	SpecifyStartup              *string `xml:"specify_startup,omitempty"`
	StartRebootTimerImmediately *bool   `xml:"start_reboot_timer_immediately,omitempty"`
	StartupDisk                 *string `xml:"startup_disk,omitempty"`
	UserLoggedIn                *string `xml:"user_logged_in,omitempty"`
}

PolicyPostReboot represents a policy post reboot.

func (PolicyPostReboot) MarshalXML 

func (t PolicyPostReboot) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyPostReboot root element name to the wire value declared by the spec (<reboot>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPostScope 

type PolicyPostScope struct {
	XMLName        xml.Name
	ID             *int                       `xml:"id,omitempty"`
	AllComputers   *bool                      `xml:"all_computers,omitempty"`
	AllJssUsers    *bool                      `xml:"all_jss_users,omitempty"`
	Buildings      *PolicyScopeBuildings      `xml:"buildings,omitempty"`
	ComputerGroups *PolicyScopeComputerGroups `xml:"computer_groups,omitempty"`
	Computers      *PolicyScopeComputers      `xml:"computers,omitempty"`
	Departments    *PolicyScopeDepartments    `xml:"departments,omitempty"`
	Exclusions     *PolicyScopeExclusions     `xml:"exclusions,omitempty"`
	JssUserGroups  *PolicyScopeJssUserGroups  `xml:"jss_user_groups,omitempty"`
	JssUsers       *PolicyScopeJssUsers       `xml:"jss_users,omitempty"`
	LimitToUsers   *PolicyScopeLimitToUsers   `xml:"limit_to_users,omitempty"`
	Limitations    *PolicyScopeLimitations    `xml:"limitations,omitempty"`
}

PolicyPostScope represents a policy post scope.

func (PolicyPostScope) MarshalXML 

func (t PolicyPostScope) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyPostScope root element name to the wire value declared by the spec (<scope>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPostScripts 

type PolicyPostScripts struct {
	XMLName xml.Name
	Script  *[]PolicyScriptsScriptItem `xml:"script,omitempty"`
	Size    *Size                      `xml:"size,omitempty"`
}

PolicyPostScripts represents a policy post scripts.

func (PolicyPostScripts) MarshalXML 

func (t PolicyPostScripts) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyPostScripts root element name to the wire value declared by the spec (<scripts>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPostSelfService 

type PolicyPostSelfService struct {
	XMLName                     xml.Name
	ID                          *int                                    `xml:"id,omitempty"`
	FeatureOnMainPage           *bool                                   `xml:"feature_on_main_page,omitempty"`
	ForceUsersToViewDescription *bool                                   `xml:"force_users_to_view_description,omitempty"`
	InstallButtonText           *string                                 `xml:"install_button_text,omitempty"`
	Notification                *NotificationValue                      `xml:"notification"`
	NotificationMessage         *string                                 `xml:"notification_message,omitempty"`
	NotificationSubject         *string                                 `xml:"notification_subject,omitempty"`
	NotificationType            *string                                 `xml:"notification_type,omitempty"`
	ReinstallButtonText         *string                                 `xml:"reinstall_button_text,omitempty"`
	SelfServiceCategories       *PolicySelfServiceSelfServiceCategories `xml:"self_service_categories,omitempty"`
	SelfServiceDescription      *string                                 `xml:"self_service_description,omitempty"`
	SelfServiceDisplayName      *string                                 `xml:"self_service_display_name,omitempty"`
	SelfServiceIcon             *PolicySelfServiceSelfServiceIcon       `xml:"self_service_icon,omitempty"`
	UseForSelfService           *bool                                   `xml:"use_for_self_service,omitempty"`
}

PolicyPostSelfService represents a policy post self service.

func (PolicyPostSelfService) MarshalXML 

func (t PolicyPostSelfService) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyPostSelfService root element name to the wire value declared by the spec (<self_service>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPostUserInteraction 

type PolicyPostUserInteraction struct {
	XMLName               xml.Name
	AllowDeferralMinutes  *int    `xml:"allow_deferral_minutes,omitempty"`
	AllowDeferralUntilUtc *string `xml:"allow_deferral_until_utc,omitempty"`
	AllowUsersToDefer     *bool   `xml:"allow_users_to_defer,omitempty"`
	MessageFinish         *string `xml:"message_finish,omitempty"`
	MessageStart          *string `xml:"message_start,omitempty"`
}

PolicyPostUserInteraction represents a policy post user interaction.

func (PolicyPostUserInteraction) MarshalXML 

func (t PolicyPostUserInteraction) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyPostUserInteraction root element name to the wire value declared by the spec (<user_interaction>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPrinters 

type PolicyPrinters struct {
	XMLName              xml.Name
	LeaveExistingDefault *bool                        `xml:"leave_existing_default,omitempty"`
	Printer              *[]PolicyPrintersPrinterItem `xml:"printer,omitempty"`
	Size                 *int                         `xml:"size,omitempty"`
}

PolicyPrinters represents a policy printers.

func (PolicyPrinters) MarshalXML 

func (t PolicyPrinters) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyPrinters root element name to the wire value declared by the spec (<printers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPrintersPrinterItem 

type PolicyPrintersPrinterItem struct {
	XMLName xml.Name
	// Allowed values: see the PolicyPrintersPrinterItemAction constants.
	Action      *string `xml:"action,omitempty"`
	ID          *int    `xml:"id,omitempty"`
	MakeDefault *bool   `xml:"make_default,omitempty"`
	Name        *string `xml:"name,omitempty"`
}

PolicyPrintersPrinterItem represents a policy printers printer item.

func (PolicyPrintersPrinterItem) MarshalXML 

func (t PolicyPrintersPrinterItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyPrintersPrinterItem root element name to the wire value declared by the spec (<printer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyPrintersPrinterItemAction 

type PolicyPrintersPrinterItemAction = string

PolicyPrintersPrinterItemAction is the set of values accepted by PolicyPrintersPrinterItem.Action. 

const (
	PolicyPrintersPrinterItemActionInstall   PolicyPrintersPrinterItemAction = "install"
	PolicyPrintersPrinterItemActionUninstall PolicyPrintersPrinterItemAction = "uninstall"
)

PolicyPrintersPrinterItemAction 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 PolicyPrintersPrinterItemActionValues 

func PolicyPrintersPrinterItemActionValues() []PolicyPrintersPrinterItemAction

PolicyPrintersPrinterItemActionValues returns every value the Jamf API accepts for PolicyPrintersPrinterItemAction, 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 PolicyReboot 

type PolicyReboot struct {
	XMLName                     xml.Name
	FileVault2Reboot            *bool   `xml:"file_vault_2_reboot,omitempty"`
	Message                     *string `xml:"message,omitempty"`
	MinutesUntilReboot          *int    `xml:"minutes_until_reboot,omitempty"`
	NoUserLoggedIn              *string `xml:"no_user_logged_in,omitempty"`
	SpecifyStartup              *string `xml:"specify_startup,omitempty"`
	StartRebootTimerImmediately *bool   `xml:"start_reboot_timer_immediately,omitempty"`
	StartupDisk                 *string `xml:"startup_disk,omitempty"`
	UserLoggedIn                *string `xml:"user_logged_in,omitempty"`
}

PolicyReboot represents a policy reboot.

func (PolicyReboot) MarshalXML 

func (t PolicyReboot) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyReboot root element name to the wire value declared by the spec (<reboot>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScope 

type PolicyScope struct {
	XMLName        xml.Name
	ID             *int                       `xml:"id,omitempty"`
	AllComputers   *bool                      `xml:"all_computers,omitempty"`
	AllJssUsers    *bool                      `xml:"all_jss_users,omitempty"`
	Buildings      *PolicyScopeBuildings      `xml:"buildings,omitempty"`
	ComputerGroups *PolicyScopeComputerGroups `xml:"computer_groups,omitempty"`
	Computers      *PolicyScopeComputers      `xml:"computers,omitempty"`
	Departments    *PolicyScopeDepartments    `xml:"departments,omitempty"`
	Exclusions     *PolicyScopeExclusions     `xml:"exclusions,omitempty"`
	JssUserGroups  *PolicyScopeJssUserGroups  `xml:"jss_user_groups,omitempty"`
	JssUsers       *PolicyScopeJssUsers       `xml:"jss_users,omitempty"`
	LimitToUsers   *PolicyScopeLimitToUsers   `xml:"limit_to_users,omitempty"`
	Limitations    *PolicyScopeLimitations    `xml:"limitations,omitempty"`
}

PolicyScope represents a policy scope.

func (PolicyScope) MarshalXML 

func (t PolicyScope) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScope root element name to the wire value declared by the spec (<scope>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeBuildings 

type PolicyScopeBuildings struct {
	XMLName  xml.Name
	Building *[]IDName `xml:"building,omitempty"`
}

PolicyScopeBuildings represents a policy scope buildings.

func (PolicyScopeBuildings) MarshalXML 

func (t PolicyScopeBuildings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeBuildings root element name to the wire value declared by the spec (<buildings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeComputerGroups 

type PolicyScopeComputerGroups struct {
	XMLName       xml.Name
	ComputerGroup *[]IDName `xml:"computer_group,omitempty"`
}

PolicyScopeComputerGroups represents a policy scope computer groups.

func (PolicyScopeComputerGroups) MarshalXML 

func (t PolicyScopeComputerGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeComputerGroups root element name to the wire value declared by the spec (<computer_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeComputers 

type PolicyScopeComputers struct {
	XMLName  xml.Name
	Computer *[]PolicyScopeComputersComputerItem `xml:"computer,omitempty"`
}

PolicyScopeComputers represents a policy scope computers.

func (PolicyScopeComputers) MarshalXML 

func (t PolicyScopeComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeComputersComputerItem 

type PolicyScopeComputersComputerItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the computer.
	Name *string `xml:"name,omitempty"`
	UDID *string `xml:"udid,omitempty"`
}

PolicyScopeComputersComputerItem represents a policy scope computers computer item.

func (PolicyScopeComputersComputerItem) MarshalXML 

func (t PolicyScopeComputersComputerItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeComputersComputerItem root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeDepartments 

type PolicyScopeDepartments struct {
	XMLName    xml.Name
	Department *[]IDName `xml:"department,omitempty"`
}

PolicyScopeDepartments represents a policy scope departments.

func (PolicyScopeDepartments) MarshalXML 

func (t PolicyScopeDepartments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeDepartments root element name to the wire value declared by the spec (<departments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeExclusions 

type PolicyScopeExclusions struct {
	XMLName         xml.Name
	ID              *int                                  `xml:"id,omitempty"`
	Buildings       *PolicyScopeExclusionsBuildings       `xml:"buildings,omitempty"`
	ComputerGroups  *PolicyScopeExclusionsComputerGroups  `xml:"computer_groups,omitempty"`
	Computers       *PolicyScopeExclusionsComputers       `xml:"computers,omitempty"`
	Departments     *PolicyScopeExclusionsDepartments     `xml:"departments,omitempty"`
	Ibeacons        *PolicyScopeExclusionsIbeacons        `xml:"ibeacons,omitempty"`
	JssUserGroups   *PolicyScopeExclusionsJssUserGroups   `xml:"jss_user_groups,omitempty"`
	JssUsers        *PolicyScopeExclusionsJssUsers        `xml:"jss_users,omitempty"`
	NetworkSegments *PolicyScopeExclusionsNetworkSegments `xml:"network_segments,omitempty"`
	UserGroups      *PolicyScopeExclusionsUserGroups      `xml:"user_groups,omitempty"`
	Users           *PolicyScopeExclusionsUsers           `xml:"users,omitempty"`
}

PolicyScopeExclusions represents a policy scope exclusions.

func (PolicyScopeExclusions) MarshalXML 

func (t PolicyScopeExclusions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeExclusions root element name to the wire value declared by the spec (<exclusions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeExclusionsBuildings 

type PolicyScopeExclusionsBuildings struct {
	XMLName  xml.Name
	Building *[]IDName `xml:"building,omitempty"`
}

PolicyScopeExclusionsBuildings represents a policy scope exclusions buildings.

func (PolicyScopeExclusionsBuildings) MarshalXML 

func (t PolicyScopeExclusionsBuildings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeExclusionsBuildings root element name to the wire value declared by the spec (<buildings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeExclusionsComputerGroups 

type PolicyScopeExclusionsComputerGroups struct {
	XMLName       xml.Name
	ComputerGroup *[]IDName `xml:"computer_group,omitempty"`
}

PolicyScopeExclusionsComputerGroups represents a policy scope exclusions computer groups.

func (PolicyScopeExclusionsComputerGroups) MarshalXML 

func (t PolicyScopeExclusionsComputerGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeExclusionsComputerGroups root element name to the wire value declared by the spec (<computer_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeExclusionsComputers 

type PolicyScopeExclusionsComputers struct {
	XMLName  xml.Name
	Computer *[]PolicyScopeExclusionsComputersComputerItem `xml:"computer,omitempty"`
}

PolicyScopeExclusionsComputers represents a policy scope exclusions computers.

func (PolicyScopeExclusionsComputers) MarshalXML 

func (t PolicyScopeExclusionsComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeExclusionsComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeExclusionsComputersComputerItem 

type PolicyScopeExclusionsComputersComputerItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the computer.
	Name *string `xml:"name,omitempty"`
	UDID *string `xml:"udid,omitempty"`
}

PolicyScopeExclusionsComputersComputerItem represents a policy scope exclusions computers computer item.

func (PolicyScopeExclusionsComputersComputerItem) MarshalXML 

func (t PolicyScopeExclusionsComputersComputerItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeExclusionsComputersComputerItem root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeExclusionsDepartments 

type PolicyScopeExclusionsDepartments struct {
	XMLName    xml.Name
	Department *[]IDName `xml:"department,omitempty"`
}

PolicyScopeExclusionsDepartments represents a policy scope exclusions departments.

func (PolicyScopeExclusionsDepartments) MarshalXML 

func (t PolicyScopeExclusionsDepartments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeExclusionsDepartments root element name to the wire value declared by the spec (<departments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeExclusionsIbeacons 

type PolicyScopeExclusionsIbeacons struct {
	XMLName xml.Name
	Ibeacon *[]IDName `xml:"ibeacon,omitempty"`
}

PolicyScopeExclusionsIbeacons represents a policy scope exclusions ibeacons.

func (PolicyScopeExclusionsIbeacons) MarshalXML 

func (t PolicyScopeExclusionsIbeacons) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeExclusionsIbeacons root element name to the wire value declared by the spec (<ibeacons>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeExclusionsJssUserGroups 

type PolicyScopeExclusionsJssUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

PolicyScopeExclusionsJssUserGroups represents a policy scope exclusions jss user groups.

func (PolicyScopeExclusionsJssUserGroups) MarshalXML 

func (t PolicyScopeExclusionsJssUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeExclusionsJssUserGroups root element name to the wire value declared by the spec (<jss_user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeExclusionsJssUsers 

type PolicyScopeExclusionsJssUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

PolicyScopeExclusionsJssUsers represents a policy scope exclusions jss users.

func (PolicyScopeExclusionsJssUsers) MarshalXML 

func (t PolicyScopeExclusionsJssUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeExclusionsJssUsers root element name to the wire value declared by the spec (<jss_users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeExclusionsNetworkSegments 

type PolicyScopeExclusionsNetworkSegments struct {
	XMLName        xml.Name
	NetworkSegment *[]PolicyScopeExclusionsNetworkSegmentsNetworkSegmentItem `xml:"network_segment,omitempty"`
}

PolicyScopeExclusionsNetworkSegments represents a policy scope exclusions network segments.

func (PolicyScopeExclusionsNetworkSegments) MarshalXML 

func (t PolicyScopeExclusionsNetworkSegments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeExclusionsNetworkSegments root element name to the wire value declared by the spec (<network_segments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeExclusionsNetworkSegmentsNetworkSegmentItem 

type PolicyScopeExclusionsNetworkSegmentsNetworkSegmentItem struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the network segment.
	Name *string `xml:"name,omitempty"`
	Uid  *string `xml:"uid,omitempty"`
}

PolicyScopeExclusionsNetworkSegmentsNetworkSegmentItem represents a policy scope exclusions network segments network segment item.

func (PolicyScopeExclusionsNetworkSegmentsNetworkSegmentItem) MarshalXML 

func (t PolicyScopeExclusionsNetworkSegmentsNetworkSegmentItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeExclusionsNetworkSegmentsNetworkSegmentItem root element name to the wire value declared by the spec (<network_segment>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeExclusionsUserGroups 

type PolicyScopeExclusionsUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

PolicyScopeExclusionsUserGroups represents a policy scope exclusions user groups.

func (PolicyScopeExclusionsUserGroups) MarshalXML 

func (t PolicyScopeExclusionsUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeExclusionsUserGroups root element name to the wire value declared by the spec (<user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeExclusionsUsers 

type PolicyScopeExclusionsUsers struct {
	XMLName xml.Name
	User    *[]PolicyScopeExclusionsUsersUserItem `xml:"user,omitempty"`
}

PolicyScopeExclusionsUsers represents a policy scope exclusions users.

func (PolicyScopeExclusionsUsers) MarshalXML 

func (t PolicyScopeExclusionsUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeExclusionsUsers root element name to the wire value declared by the spec (<users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeExclusionsUsersUserItem 

type PolicyScopeExclusionsUsersUserItem struct {
	XMLName xml.Name
	Name    *string `xml:"name,omitempty"`
}

PolicyScopeExclusionsUsersUserItem represents a policy scope exclusions users user item.

func (PolicyScopeExclusionsUsersUserItem) MarshalXML 

func (t PolicyScopeExclusionsUsersUserItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeExclusionsUsersUserItem root element name to the wire value declared by the spec (<user>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeJssUserGroups 

type PolicyScopeJssUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

PolicyScopeJssUserGroups represents a policy scope jss user groups.

func (PolicyScopeJssUserGroups) MarshalXML 

func (t PolicyScopeJssUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeJssUserGroups root element name to the wire value declared by the spec (<jss_user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeJssUsers 

type PolicyScopeJssUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

PolicyScopeJssUsers represents a policy scope jss users.

func (PolicyScopeJssUsers) MarshalXML 

func (t PolicyScopeJssUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeJssUsers root element name to the wire value declared by the spec (<jss_users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeLimitToUsers 

type PolicyScopeLimitToUsers struct {
	XMLName    xml.Name
	ID         *int                               `xml:"id,omitempty"`
	UserGroups *PolicyScopeLimitToUsersUserGroups `xml:"user_groups,omitempty"`
}

PolicyScopeLimitToUsers represents a policy scope limit to users.

func (PolicyScopeLimitToUsers) MarshalXML 

func (t PolicyScopeLimitToUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeLimitToUsers root element name to the wire value declared by the spec (<limit_to_users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeLimitToUsersUserGroups 

type PolicyScopeLimitToUsersUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]string `xml:"user_group,omitempty"`
}

PolicyScopeLimitToUsersUserGroups represents a policy scope limit to users user groups.

func (PolicyScopeLimitToUsersUserGroups) MarshalXML 

func (t PolicyScopeLimitToUsersUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeLimitToUsersUserGroups root element name to the wire value declared by the spec (<user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeLimitations 

type PolicyScopeLimitations struct {
	XMLName         xml.Name
	ID              *int                                   `xml:"id,omitempty"`
	Ibeacons        *PolicyScopeLimitationsIbeacons        `xml:"ibeacons,omitempty"`
	NetworkSegments *PolicyScopeLimitationsNetworkSegments `xml:"network_segments,omitempty"`
	UserGroups      *PolicyScopeLimitationsUserGroups      `xml:"user_groups,omitempty"`
	Users           *PolicyScopeLimitationsUsers           `xml:"users,omitempty"`
}

PolicyScopeLimitations represents a policy scope limitations.

func (PolicyScopeLimitations) MarshalXML 

func (t PolicyScopeLimitations) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeLimitations root element name to the wire value declared by the spec (<limitations>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeLimitationsIbeacons 

type PolicyScopeLimitationsIbeacons struct {
	XMLName xml.Name
	Ibeacon *[]IDName `xml:"ibeacon,omitempty"`
}

PolicyScopeLimitationsIbeacons represents a policy scope limitations ibeacons.

func (PolicyScopeLimitationsIbeacons) MarshalXML 

func (t PolicyScopeLimitationsIbeacons) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeLimitationsIbeacons root element name to the wire value declared by the spec (<ibeacons>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeLimitationsNetworkSegments 

type PolicyScopeLimitationsNetworkSegments struct {
	XMLName        xml.Name
	NetworkSegment *[]IDName `xml:"network_segment,omitempty"`
}

PolicyScopeLimitationsNetworkSegments represents a policy scope limitations network segments.

func (PolicyScopeLimitationsNetworkSegments) MarshalXML 

func (t PolicyScopeLimitationsNetworkSegments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeLimitationsNetworkSegments root element name to the wire value declared by the spec (<network_segments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeLimitationsUserGroups 

type PolicyScopeLimitationsUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

PolicyScopeLimitationsUserGroups represents a policy scope limitations user groups.

func (PolicyScopeLimitationsUserGroups) MarshalXML 

func (t PolicyScopeLimitationsUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeLimitationsUserGroups root element name to the wire value declared by the spec (<user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScopeLimitationsUsers 

type PolicyScopeLimitationsUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

PolicyScopeLimitationsUsers represents a policy scope limitations users.

func (PolicyScopeLimitationsUsers) MarshalXML 

func (t PolicyScopeLimitationsUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScopeLimitationsUsers root element name to the wire value declared by the spec (<users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScripts 

type PolicyScripts struct {
	XMLName xml.Name
	Script  *[]PolicyScriptsScriptItem `xml:"script,omitempty"`
	Size    *Size                      `xml:"size,omitempty"`
}

PolicyScripts represents a policy scripts.

func (PolicyScripts) MarshalXML 

func (t PolicyScripts) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScripts root element name to the wire value declared by the spec (<scripts>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScriptsScriptItem 

type PolicyScriptsScriptItem struct {
	XMLName     xml.Name
	ID          *int    `xml:"id,omitempty"`
	Name        *string `xml:"name,omitempty"`
	Parameter10 *string `xml:"parameter10,omitempty"`
	Parameter11 *string `xml:"parameter11,omitempty"`
	Parameter4  *string `xml:"parameter4,omitempty"`
	Parameter5  *string `xml:"parameter5,omitempty"`
	Parameter6  *string `xml:"parameter6,omitempty"`
	Parameter7  *string `xml:"parameter7,omitempty"`
	Parameter8  *string `xml:"parameter8,omitempty"`
	Parameter9  *string `xml:"parameter9,omitempty"`
	// Allowed values: see the PolicyScriptsScriptItemPriority constants.
	Priority *string `xml:"priority,omitempty"`
}

PolicyScriptsScriptItem represents a policy scripts script item.

func (PolicyScriptsScriptItem) MarshalXML 

func (t PolicyScriptsScriptItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyScriptsScriptItem root element name to the wire value declared by the spec (<script>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyScriptsScriptItemPriority 

type PolicyScriptsScriptItemPriority = string

PolicyScriptsScriptItemPriority is the set of values accepted by PolicyScriptsScriptItem.Priority. 

const (
	PolicyScriptsScriptItemPriorityBefore PolicyScriptsScriptItemPriority = "Before"
	PolicyScriptsScriptItemPriorityAfter  PolicyScriptsScriptItemPriority = "After"
)

PolicyScriptsScriptItemPriority 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 PolicyScriptsScriptItemPriorityValues 

func PolicyScriptsScriptItemPriorityValues() []PolicyScriptsScriptItemPriority

PolicyScriptsScriptItemPriorityValues returns every value the Jamf API accepts for PolicyScriptsScriptItemPriority, 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 PolicySelfService 

type PolicySelfService struct {
	XMLName                     xml.Name
	ID                          *int                                    `xml:"id,omitempty"`
	FeatureOnMainPage           *bool                                   `xml:"feature_on_main_page,omitempty"`
	ForceUsersToViewDescription *bool                                   `xml:"force_users_to_view_description,omitempty"`
	InstallButtonText           *string                                 `xml:"install_button_text,omitempty"`
	Notification                *NotificationValue                      `xml:"notification"`
	NotificationMessage         *string                                 `xml:"notification_message,omitempty"`
	NotificationSubject         *string                                 `xml:"notification_subject,omitempty"`
	NotificationType            *string                                 `xml:"notification_type,omitempty"`
	ReinstallButtonText         *string                                 `xml:"reinstall_button_text,omitempty"`
	SelfServiceCategories       *PolicySelfServiceSelfServiceCategories `xml:"self_service_categories,omitempty"`
	SelfServiceDescription      *string                                 `xml:"self_service_description,omitempty"`
	SelfServiceDisplayName      *string                                 `xml:"self_service_display_name,omitempty"`
	SelfServiceIcon             *PolicySelfServiceSelfServiceIcon       `xml:"self_service_icon,omitempty"`
	UseForSelfService           *bool                                   `xml:"use_for_self_service,omitempty"`
}

PolicySelfService represents a policy self service.

func (PolicySelfService) MarshalXML 

func (t PolicySelfService) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicySelfService root element name to the wire value declared by the spec (<self_service>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicySelfServiceSelfServiceCategories 

type PolicySelfServiceSelfServiceCategories struct {
	XMLName  xml.Name
	Category *[]PolicySelfServiceSelfServiceCategoriesCategoryItem `xml:"category,omitempty"`
}

PolicySelfServiceSelfServiceCategories represents a policy self service self service categories.

func (PolicySelfServiceSelfServiceCategories) MarshalXML 

func (t PolicySelfServiceSelfServiceCategories) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicySelfServiceSelfServiceCategories root element name to the wire value declared by the spec (<self_service_categories>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicySelfServiceSelfServiceCategoriesCategoryItem 

type PolicySelfServiceSelfServiceCategoriesCategoryItem struct {
	XMLName   xml.Name
	DisplayIn *bool   `xml:"display_in,omitempty"`
	FeatureIn *bool   `xml:"feature_in,omitempty"`
	ID        *int    `xml:"id,omitempty"`
	Name      *string `xml:"name,omitempty"`
}

PolicySelfServiceSelfServiceCategoriesCategoryItem represents a policy self service self service categories category item.

func (PolicySelfServiceSelfServiceCategoriesCategoryItem) MarshalXML 

func (t PolicySelfServiceSelfServiceCategoriesCategoryItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicySelfServiceSelfServiceCategoriesCategoryItem root element name to the wire value declared by the spec (<category>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicySelfServiceSelfServiceIcon 

type PolicySelfServiceSelfServiceIcon struct {
	XMLName  xml.Name
	Filename *string `xml:"filename,omitempty"`
	ID       *int    `xml:"id,omitempty"`
	URI      *string `xml:"uri,omitempty"`
}

PolicySelfServiceSelfServiceIcon represents a policy self service self service icon.

func (PolicySelfServiceSelfServiceIcon) MarshalXML 

func (t PolicySelfServiceSelfServiceIcon) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicySelfServiceSelfServiceIcon root element name to the wire value declared by the spec (<self_service_icon>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PolicyUserInteraction 

type PolicyUserInteraction struct {
	XMLName               xml.Name
	AllowDeferralMinutes  *int    `xml:"allow_deferral_minutes,omitempty"`
	AllowDeferralUntilUtc *string `xml:"allow_deferral_until_utc,omitempty"`
	AllowUsersToDefer     *bool   `xml:"allow_users_to_defer,omitempty"`
	MessageFinish         *string `xml:"message_finish,omitempty"`
	MessageStart          *string `xml:"message_start,omitempty"`
}

PolicyUserInteraction represents a policy user interaction.

func (PolicyUserInteraction) MarshalXML 

func (t PolicyUserInteraction) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PolicyUserInteraction root element name to the wire value declared by the spec (<user_interaction>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Printer 

type Printer struct {
	XMLName     xml.Name
	CUPSName    *string `xml:"CUPS_name,omitempty"`
	Category    *string `xml:"category,omitempty"`
	ID          *int    `xml:"id,omitempty"`
	Info        *string `xml:"info,omitempty"`
	Location    *string `xml:"location,omitempty"`
	MakeDefault *bool   `xml:"make_default,omitempty"`
	Model       *string `xml:"model,omitempty"`
	// Name of the printer.
	Name           *string `xml:"name,omitempty"`
	Notes          *string `xml:"notes,omitempty"`
	OsRequirements *string `xml:"os_requirements,omitempty"`
	Ppd            *string `xml:"ppd,omitempty"`
	PpdContents    *string `xml:"ppd_contents,omitempty"`
	PpdPath        *string `xml:"ppd_path,omitempty"`
	Shared         *bool   `xml:"shared,omitempty"`
	URI            *string `xml:"uri,omitempty"`
	UseGeneric     *bool   `xml:"use_generic,omitempty"`
}

Printer represents a printer.

func (Printer) MarshalXML 

func (t Printer) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Printer root element name to the wire value declared by the spec (<printer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Printers 

type Printers struct {
	XMLName  xml.Name
	Size     *Size    `xml:"size,omitempty"`
	Printers []IDName `xml:"printer"`
}

Printers wraps a Jamf Classic list response with a flat slice of IDName.

func (Printers) MarshalXML 

func (t Printers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Printers root element name to the wire value declared by the spec (<printers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type PrintersItem 

type PrintersItem struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Printer *IDName `xml:"printer,omitempty"`
	Size    *Size   `xml:"size,omitempty"`
}

PrintersItem represents a printers item.

func (PrintersItem) MarshalXML 

func (t PrintersItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the PrintersItem root element name to the wire value declared by the spec (<printer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Purchasing 

type Purchasing struct {
	XMLName              xml.Name
	ApplecareID          *string `xml:"applecare_id,omitempty"`
	IsLeased             *bool   `xml:"is_leased,omitempty"`
	IsPurchased          *bool   `xml:"is_purchased,omitempty"`
	LeaseExpires         *string `xml:"lease_expires,omitempty"`
	LeaseExpiresEpoch    *int    `xml:"lease_expires_epoch,omitempty"`
	LeaseExpiresUtc      *string `xml:"lease_expires_utc,omitempty"`
	LifeExpectancy       *int    `xml:"life_expectancy,omitempty"`
	PoDate               *string `xml:"po_date,omitempty"`
	PoDateEpoch          *int    `xml:"po_date_epoch,omitempty"`
	PoDateUtc            *string `xml:"po_date_utc,omitempty"`
	PoNumber             *string `xml:"po_number,omitempty"`
	PurchasePrice        *string `xml:"purchase_price,omitempty"`
	PurchasingAccount    *string `xml:"purchasing_account,omitempty"`
	PurchasingContact    *string `xml:"purchasing_contact,omitempty"`
	Vendor               *string `xml:"vendor,omitempty"`
	WarrantyExpires      *string `xml:"warranty_expires,omitempty"`
	WarrantyExpiresEpoch *int    `xml:"warranty_expires_epoch,omitempty"`
	WarrantyExpiresUtc   *string `xml:"warranty_expires_utc,omitempty"`
}

Purchasing represents a purchasing.

func (Purchasing) MarshalXML 

func (t Purchasing) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Purchasing root element name to the wire value declared by the spec (<purchasing>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type RemovableMacAddress 

type RemovableMacAddress struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// MAC address to ignore when identifying computers.
	Name *string `xml:"name,omitempty"`
}

RemovableMacAddress represents a removable mac address.

func (RemovableMacAddress) MarshalXML 

func (t RemovableMacAddress) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the RemovableMacAddress root element name to the wire value declared by the spec (<removable_mac_address>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type RemovableMacAddresses 

type RemovableMacAddresses struct {
	XMLName               xml.Name
	RemovableMacAddresses []RemovableMacAddress `xml:"removable_mac_address"`
}

RemovableMacAddresses wraps a Jamf Classic list response with a flat slice of RemovableMacAddress.

func (RemovableMacAddresses) MarshalXML 

func (t RemovableMacAddresses) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the RemovableMacAddresses root element name to the wire value declared by the spec (<removable_mac_addresses>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type RemovableMacAddressesItem 

type RemovableMacAddressesItem struct {
	XMLName             xml.Name
	ID                  *int                 `xml:"id,omitempty"`
	RemovableMacAddress *RemovableMacAddress `xml:"removable_mac_address,omitempty"`
}

RemovableMacAddressesItem represents a removable mac addresses item.

func (RemovableMacAddressesItem) MarshalXML 

func (t RemovableMacAddressesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the RemovableMacAddressesItem root element name to the wire value declared by the spec (<removable_mac_address>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type RestrictedSoftware 

type RestrictedSoftware struct {
	XMLName xml.Name
	ID      *int                       `xml:"id,omitempty"`
	General *RestrictedSoftwareGeneral `xml:"general,omitempty"`
	Scope   *RestrictedSoftwareScope   `xml:"scope,omitempty"`
}

RestrictedSoftware represents a restricted software.

func (RestrictedSoftware) MarshalXML 

func (t RestrictedSoftware) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the RestrictedSoftware root element name to the wire value declared by the spec (<restricted_software>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type RestrictedSoftwareAll 

type RestrictedSoftwareAll struct {
	XMLName                  xml.Name
	Size                     *Size    `xml:"size,omitempty"`
	RestrictedSoftwareTitles []IDName `xml:"restricted_software_title"`
}

RestrictedSoftwareAll wraps a Jamf Classic list response with a flat slice of IDName.

func (RestrictedSoftwareAll) MarshalXML 

func (t RestrictedSoftwareAll) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the RestrictedSoftwareAll root element name to the wire value declared by the spec (<restricted_software_all>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type RestrictedSoftwareAllItem 

type RestrictedSoftwareAllItem struct {
	XMLName                 xml.Name
	ID                      *int    `xml:"id,omitempty"`
	RestrictedSoftwareTitle *IDName `xml:"restricted_software_title,omitempty"`
	Size                    *Size   `xml:"size,omitempty"`
}

RestrictedSoftwareAllItem represents a restricted software all item.

func (RestrictedSoftwareAllItem) MarshalXML 

func (t RestrictedSoftwareAllItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the RestrictedSoftwareAllItem root element name to the wire value declared by the spec (<restricted_software_all>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type RestrictedSoftwareGeneral 

type RestrictedSoftwareGeneral struct {
	XMLName               xml.Name
	DeleteExecutable      *bool   `xml:"delete_executable,omitempty"`
	DisplayMessage        *string `xml:"display_message,omitempty"`
	ID                    *int    `xml:"id,omitempty"`
	KillProcess           *bool   `xml:"kill_process,omitempty"`
	MatchExactProcessName *bool   `xml:"match_exact_process_name,omitempty"`
	// Name of the restricted software.
	Name             *string     `xml:"name,omitempty"`
	ProcessName      *string     `xml:"process_name,omitempty"`
	SendNotification *bool       `xml:"send_notification,omitempty"`
	Site             *SiteObject `xml:"site,omitempty"`
}

RestrictedSoftwareGeneral represents a restricted software general.

func (RestrictedSoftwareGeneral) MarshalXML 

func (t RestrictedSoftwareGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the RestrictedSoftwareGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type RestrictedSoftwareScope 

type RestrictedSoftwareScope struct {
	XMLName        xml.Name
	ID             *int                                   `xml:"id,omitempty"`
	AllComputers   *bool                                  `xml:"all_computers,omitempty"`
	Buildings      *RestrictedSoftwareScopeBuildings      `xml:"buildings,omitempty"`
	ComputerGroups *RestrictedSoftwareScopeComputerGroups `xml:"computer_groups,omitempty"`
	Computers      *RestrictedSoftwareScopeComputers      `xml:"computers,omitempty"`
	Departments    *RestrictedSoftwareScopeDepartments    `xml:"departments,omitempty"`
	Exclusions     *RestrictedSoftwareScopeExclusions     `xml:"exclusions,omitempty"`
}

RestrictedSoftwareScope represents a restricted software scope.

func (RestrictedSoftwareScope) MarshalXML 

func (t RestrictedSoftwareScope) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the RestrictedSoftwareScope root element name to the wire value declared by the spec (<scope>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type RestrictedSoftwareScopeBuildings 

type RestrictedSoftwareScopeBuildings struct {
	XMLName  xml.Name
	Building *[]IDName `xml:"building,omitempty"`
}

RestrictedSoftwareScopeBuildings represents a restricted software scope buildings.

func (RestrictedSoftwareScopeBuildings) MarshalXML 

func (t RestrictedSoftwareScopeBuildings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the RestrictedSoftwareScopeBuildings root element name to the wire value declared by the spec (<buildings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type RestrictedSoftwareScopeComputerGroups 

type RestrictedSoftwareScopeComputerGroups struct {
	XMLName       xml.Name
	ComputerGroup *[]IDName `xml:"computer_group,omitempty"`
}

RestrictedSoftwareScopeComputerGroups represents a restricted software scope computer groups.

func (RestrictedSoftwareScopeComputerGroups) MarshalXML 

func (t RestrictedSoftwareScopeComputerGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the RestrictedSoftwareScopeComputerGroups root element name to the wire value declared by the spec (<computer_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type RestrictedSoftwareScopeComputers 

type RestrictedSoftwareScopeComputers struct {
	XMLName  xml.Name
	Computer *[]IDName `xml:"computer,omitempty"`
}

RestrictedSoftwareScopeComputers represents a restricted software scope computers.

func (RestrictedSoftwareScopeComputers) MarshalXML 

func (t RestrictedSoftwareScopeComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the RestrictedSoftwareScopeComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type RestrictedSoftwareScopeDepartments 

type RestrictedSoftwareScopeDepartments struct {
	XMLName    xml.Name
	Department *[]IDName `xml:"department,omitempty"`
}

RestrictedSoftwareScopeDepartments represents a restricted software scope departments.

func (RestrictedSoftwareScopeDepartments) MarshalXML 

func (t RestrictedSoftwareScopeDepartments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the RestrictedSoftwareScopeDepartments root element name to the wire value declared by the spec (<departments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type RestrictedSoftwareScopeExclusions 

type RestrictedSoftwareScopeExclusions struct {
	XMLName        xml.Name
	ID             *int                                             `xml:"id,omitempty"`
	Buildings      *RestrictedSoftwareScopeExclusionsBuildings      `xml:"buildings,omitempty"`
	ComputerGroups *RestrictedSoftwareScopeExclusionsComputerGroups `xml:"computer_groups,omitempty"`
	Computers      *RestrictedSoftwareScopeExclusionsComputers      `xml:"computers,omitempty"`
	Departments    *RestrictedSoftwareScopeExclusionsDepartments    `xml:"departments,omitempty"`
	Users          *RestrictedSoftwareScopeExclusionsUsers          `xml:"users,omitempty"`
}

RestrictedSoftwareScopeExclusions represents a restricted software scope exclusions.

func (RestrictedSoftwareScopeExclusions) MarshalXML 

func (t RestrictedSoftwareScopeExclusions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the RestrictedSoftwareScopeExclusions root element name to the wire value declared by the spec (<exclusions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type RestrictedSoftwareScopeExclusionsBuildings 

type RestrictedSoftwareScopeExclusionsBuildings struct {
	XMLName  xml.Name
	Building *[]IDName `xml:"building,omitempty"`
}

RestrictedSoftwareScopeExclusionsBuildings represents a restricted software scope exclusions buildings.

func (RestrictedSoftwareScopeExclusionsBuildings) MarshalXML 

func (t RestrictedSoftwareScopeExclusionsBuildings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the RestrictedSoftwareScopeExclusionsBuildings root element name to the wire value declared by the spec (<buildings>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type RestrictedSoftwareScopeExclusionsComputerGroups 

type RestrictedSoftwareScopeExclusionsComputerGroups struct {
	XMLName       xml.Name
	ComputerGroup *[]IDName `xml:"computer_group,omitempty"`
}

RestrictedSoftwareScopeExclusionsComputerGroups represents a restricted software scope exclusions computer groups.

func (RestrictedSoftwareScopeExclusionsComputerGroups) MarshalXML 

func (t RestrictedSoftwareScopeExclusionsComputerGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the RestrictedSoftwareScopeExclusionsComputerGroups root element name to the wire value declared by the spec (<computer_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type RestrictedSoftwareScopeExclusionsComputers 

type RestrictedSoftwareScopeExclusionsComputers struct {
	XMLName  xml.Name
	Computer *[]IDName `xml:"computer,omitempty"`
}

RestrictedSoftwareScopeExclusionsComputers represents a restricted software scope exclusions computers.

func (RestrictedSoftwareScopeExclusionsComputers) MarshalXML 

func (t RestrictedSoftwareScopeExclusionsComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the RestrictedSoftwareScopeExclusionsComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type RestrictedSoftwareScopeExclusionsDepartments 

type RestrictedSoftwareScopeExclusionsDepartments struct {
	XMLName    xml.Name
	Department *[]IDName `xml:"department,omitempty"`
}

RestrictedSoftwareScopeExclusionsDepartments represents a restricted software scope exclusions departments.

func (RestrictedSoftwareScopeExclusionsDepartments) MarshalXML 

func (t RestrictedSoftwareScopeExclusionsDepartments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the RestrictedSoftwareScopeExclusionsDepartments root element name to the wire value declared by the spec (<departments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type RestrictedSoftwareScopeExclusionsUsers 

type RestrictedSoftwareScopeExclusionsUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

RestrictedSoftwareScopeExclusionsUsers represents a restricted software scope exclusions users.

func (RestrictedSoftwareScopeExclusionsUsers) MarshalXML 

func (t RestrictedSoftwareScopeExclusionsUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the RestrictedSoftwareScopeExclusionsUsers root element name to the wire value declared by the spec (<users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type SavedSearches 

type SavedSearches struct {
	XMLName       xml.Name
	Size          *int                           `xml:"size,omitempty"`
	SavedSearches []SavedSearchesItemSavedSearch `xml:"saved_search"`
}

SavedSearches wraps a Jamf Classic list response with a flat slice of SavedSearchesItemSavedSearch.

func (SavedSearches) MarshalXML 

func (t SavedSearches) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the SavedSearches root element name to the wire value declared by the spec (<saved_searches>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type SavedSearchesItem 

type SavedSearchesItem struct {
	XMLName     xml.Name
	ID          *int                          `xml:"id,omitempty"`
	SavedSearch *SavedSearchesItemSavedSearch `xml:"saved_search,omitempty"`
	Size        *int                          `xml:"size,omitempty"`
}

SavedSearchesItem represents a saved searches item.

func (SavedSearchesItem) MarshalXML 

func (t SavedSearchesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the SavedSearchesItem root element name to the wire value declared by the spec (<saved_searche>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type SavedSearchesItemSavedSearch 

type SavedSearchesItemSavedSearch struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
	// Allowed values: see the SavedSearchesItemSavedSearchType constants.
	Type *string `xml:"type,omitempty"`
}

SavedSearchesItemSavedSearch represents a saved searches item saved search.

func (SavedSearchesItemSavedSearch) MarshalXML 

func (t SavedSearchesItemSavedSearch) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the SavedSearchesItemSavedSearch root element name to the wire value declared by the spec (<saved_search>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type SavedSearchesItemSavedSearchType 

type SavedSearchesItemSavedSearchType = string

SavedSearchesItemSavedSearchType is the set of values accepted by SavedSearchesItemSavedSearch.Type. 

const (
	SavedSearchesItemSavedSearchTypeComputers     SavedSearchesItemSavedSearchType = "Computers"
	SavedSearchesItemSavedSearchTypeMobileDevices SavedSearchesItemSavedSearchType = "Mobile Devices"
	SavedSearchesItemSavedSearchTypeUsers         SavedSearchesItemSavedSearchType = "Users"
)

SavedSearchesItemSavedSearchType 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 SavedSearchesItemSavedSearchTypeValues 

func SavedSearchesItemSavedSearchTypeValues() []SavedSearchesItemSavedSearchType

SavedSearchesItemSavedSearchTypeValues returns every value the Jamf API accepts for SavedSearchesItemSavedSearchType, 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 Script 

type Script struct {
	XMLName  xml.Name
	Category *string `xml:"category,omitempty"`
	Filename *string `xml:"filename,omitempty"`
	ID       *int    `xml:"id,omitempty"`
	Info     *string `xml:"info,omitempty"`
	// Name of the script.
	Name           *string           `xml:"name,omitempty"`
	Notes          *string           `xml:"notes,omitempty"`
	OsRequirements *string           `xml:"os_requirements,omitempty"`
	Parameters     *ScriptParameters `xml:"parameters,omitempty"`
	// Allowed values: see the ScriptPriority constants.
	Priority              *string `xml:"priority,omitempty"`
	ScriptContents        *string `xml:"script_contents,omitempty"`
	ScriptContentsEncoded *string `xml:"script_contents_encoded,omitempty"`
}

Script represents a script.

func (Script) MarshalXML 

func (t Script) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Script root element name to the wire value declared by the spec (<script>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ScriptParameters 

type ScriptParameters struct {
	XMLName     xml.Name
	Parameter10 *string `xml:"parameter10,omitempty"`
	Parameter11 *string `xml:"parameter11,omitempty"`
	Parameter4  *string `xml:"parameter4,omitempty"`
	Parameter5  *string `xml:"parameter5,omitempty"`
	Parameter6  *string `xml:"parameter6,omitempty"`
	Parameter7  *string `xml:"parameter7,omitempty"`
	Parameter8  *string `xml:"parameter8,omitempty"`
	Parameter9  *string `xml:"parameter9,omitempty"`
}

ScriptParameters represents a script parameters.

func (ScriptParameters) MarshalXML 

func (t ScriptParameters) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ScriptParameters root element name to the wire value declared by the spec (<parameters>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ScriptPriority 

type ScriptPriority = string

ScriptPriority is the set of values accepted by Script.Priority. 

const (
	ScriptPriorityBefore   ScriptPriority = "Before"
	ScriptPriorityAfter    ScriptPriority = "After"
	ScriptPriorityAtReboot ScriptPriority = "At Reboot"
)

ScriptPriority 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 ScriptPriorityValues 

func ScriptPriorityValues() []ScriptPriority

ScriptPriorityValues returns every value the Jamf API accepts for ScriptPriority, 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 Scripts 

type Scripts struct {
	XMLName xml.Name
	Size    *Size    `xml:"size,omitempty"`
	Scripts []IDName `xml:"script"`
}

Scripts wraps a Jamf Classic list response with a flat slice of IDName.

func (Scripts) MarshalXML 

func (t Scripts) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Scripts root element name to the wire value declared by the spec (<scripts>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type ScriptsItem 

type ScriptsItem struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Script  *IDName `xml:"script,omitempty"`
	Size    *Size   `xml:"size,omitempty"`
}

ScriptsItem represents a scripts item.

func (ScriptsItem) MarshalXML 

func (t ScriptsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the ScriptsItem root element name to the wire value declared by the spec (<script>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Site 

type Site struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the site.
	Name *string `xml:"name,omitempty"`
}

Site represents a site.

func (Site) MarshalXML 

func (t Site) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Site root element name to the wire value declared by the spec (<site>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type SiteObject 

type SiteObject struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
	// Name of the site.
	Name *string `xml:"name,omitempty"`
}

SiteObject represents a site object.

func (SiteObject) MarshalXML 

func (t SiteObject) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the SiteObject root element name to the wire value declared by the spec (<site>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Sites 

type Sites struct {
	XMLName xml.Name
	Size    *Size  `xml:"size,omitempty"`
	Sites   []Site `xml:"site"`
}

Sites wraps a Jamf Classic list response with a flat slice of Site.

func (Sites) MarshalXML 

func (t Sites) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Sites root element name to the wire value declared by the spec (<sites>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type SitesItem 

type SitesItem struct {
	XMLName xml.Name
	ID      *int  `xml:"id,omitempty"`
	Site    *Site `xml:"site,omitempty"`
	Size    *Size `xml:"size,omitempty"`
}

SitesItem represents a sites item.

func (SitesItem) MarshalXML 

func (t SitesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the SitesItem root element name to the wire value declared by the spec (<site>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Size 

type Size = int

Size is an alias for int.

type SmtpServer 

type SmtpServer struct {
	XMLName               xml.Name
	AuthorizationRequired *bool `xml:"authorization_required,omitempty"`
	Enabled               *bool `xml:"enabled,omitempty"`
	// Hostname or IP address of the SMTP server.
	Host          *string `xml:"host,omitempty"`
	Password      *string `xml:"password,omitempty"`
	Port          *int    `xml:"port,omitempty"`
	SendFromEmail *string `xml:"send_from_email,omitempty"`
	SendFromName  *string `xml:"send_from_name,omitempty"`
	Ssl           *bool   `xml:"ssl,omitempty"`
	// Measured in seconds.
	Timeout  *int    `xml:"timeout,omitempty"`
	Tls      *bool   `xml:"tls,omitempty"`
	Username *string `xml:"username,omitempty"`
}

SmtpServer represents a smtp server.

func (SmtpServer) MarshalXML 

func (t SmtpServer) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the SmtpServer root element name to the wire value declared by the spec (<smtp_server>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type SoftwareTitle 

type SoftwareTitle struct {
	XMLName  xml.Name
	Category *Category `xml:"category,omitempty"`
	ID       *int      `xml:"id,omitempty"`
	// Name of the patch software title.
	Name           *string                     `xml:"name,omitempty"`
	Notifications  *SoftwareTitleNotifications `xml:"notifications,omitempty"`
	TotalComputers *int                        `xml:"total_computers,omitempty"`
	TotalVersions  *int                        `xml:"total_versions,omitempty"`
	Versions       *SoftwareTitleVersions      `xml:"versions,omitempty"`
}

SoftwareTitle represents a software title.

func (SoftwareTitle) MarshalXML 

func (t SoftwareTitle) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the SoftwareTitle root element name to the wire value declared by the spec (<software_title>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type SoftwareTitleNotifications 

type SoftwareTitleNotifications struct {
	XMLName           xml.Name
	EmailNotification *bool `xml:"email_notification,omitempty"`
	JssNotification   *bool `xml:"jss_notification,omitempty"`
}

SoftwareTitleNotifications represents a software title notifications.

func (SoftwareTitleNotifications) MarshalXML 

func (t SoftwareTitleNotifications) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the SoftwareTitleNotifications root element name to the wire value declared by the spec (<notifications>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type SoftwareTitleVersions 

type SoftwareTitleVersions struct {
	XMLName xml.Name
	Version *[]SoftwareTitleVersionsVersionItem `xml:"version,omitempty"`
}

SoftwareTitleVersions represents a software title versions.

func (SoftwareTitleVersions) MarshalXML 

func (t SoftwareTitleVersions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the SoftwareTitleVersions root element name to the wire value declared by the spec (<versions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type SoftwareTitleVersionsVersionItem 

type SoftwareTitleVersionsVersionItem struct {
	XMLName         xml.Name
	ID              *int                                       `xml:"id,omitempty"`
	Computers       *SoftwareTitleVersionsVersionItemComputers `xml:"computers,omitempty"`
	Package         *SoftwareTitleVersionsVersionItemPackage   `xml:"package,omitempty"`
	Size            *int                                       `xml:"size,omitempty"`
	SoftwareVersion *string                                    `xml:"software_version,omitempty"`
}

SoftwareTitleVersionsVersionItem represents a software title versions version item.

func (SoftwareTitleVersionsVersionItem) MarshalXML 

func (t SoftwareTitleVersionsVersionItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the SoftwareTitleVersionsVersionItem root element name to the wire value declared by the spec (<version>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type SoftwareTitleVersionsVersionItemComputers 

type SoftwareTitleVersionsVersionItemComputers struct {
	XMLName  xml.Name
	Computer *[]SoftwareTitleVersionsVersionItemComputersComputerItem `xml:"computer,omitempty"`
}

SoftwareTitleVersionsVersionItemComputers represents a software title versions version item computers.

func (SoftwareTitleVersionsVersionItemComputers) MarshalXML 

func (t SoftwareTitleVersionsVersionItemComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the SoftwareTitleVersionsVersionItemComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type SoftwareTitleVersionsVersionItemComputersComputerItem 

type SoftwareTitleVersionsVersionItemComputersComputerItem struct {
	XMLName       xml.Name
	AltMacAddress *string `xml:"alt_mac_address,omitempty"`
	ID            *int    `xml:"id,omitempty"`
	MacAddress    *string `xml:"mac_address,omitempty"`
	Name          *string `xml:"name,omitempty"`
	SerialNumber  *string `xml:"serial_number,omitempty"`
}

SoftwareTitleVersionsVersionItemComputersComputerItem represents a software title versions version item computers computer item.

func (SoftwareTitleVersionsVersionItemComputersComputerItem) MarshalXML 

func (t SoftwareTitleVersionsVersionItemComputersComputerItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the SoftwareTitleVersionsVersionItemComputersComputerItem root element name to the wire value declared by the spec (<computer>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type SoftwareTitleVersionsVersionItemPackage 

type SoftwareTitleVersionsVersionItemPackage struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
}

SoftwareTitleVersionsVersionItemPackage represents a software title versions version item package.

func (SoftwareTitleVersionsVersionItemPackage) MarshalXML 

func (t SoftwareTitleVersionsVersionItemPackage) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the SoftwareTitleVersionsVersionItemPackage root element name to the wire value declared by the spec (<package>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type SoftwareUpdateServer 

type SoftwareUpdateServer struct {
	XMLName   xml.Name
	ID        *int    `xml:"id,omitempty"`
	IPAddress *string `xml:"ip_address,omitempty"`
	// Name of the software update server.
	Name          *string `xml:"name,omitempty"`
	Port          *int    `xml:"port,omitempty"`
	SetSystemWide *bool   `xml:"set_system_wide,omitempty"`
}

SoftwareUpdateServer represents a software update server.

func (SoftwareUpdateServer) MarshalXML 

func (t SoftwareUpdateServer) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the SoftwareUpdateServer root element name to the wire value declared by the spec (<software_update_server>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type SoftwareUpdateServers 

type SoftwareUpdateServers struct {
	XMLName               xml.Name
	Size                  *Size    `xml:"size,omitempty"`
	SoftwareUpdateServers []IDName `xml:"software_update_server"`
}

SoftwareUpdateServers wraps a Jamf Classic list response with a flat slice of IDName.

func (SoftwareUpdateServers) MarshalXML 

func (t SoftwareUpdateServers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the SoftwareUpdateServers root element name to the wire value declared by the spec (<software_update_servers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type SoftwareUpdateServersItem 

type SoftwareUpdateServersItem struct {
	XMLName              xml.Name
	ID                   *int    `xml:"id,omitempty"`
	Size                 *Size   `xml:"size,omitempty"`
	SoftwareUpdateServer *IDName `xml:"software_update_server,omitempty"`
}

SoftwareUpdateServersItem represents a software update servers item.

func (SoftwareUpdateServersItem) MarshalXML 

func (t SoftwareUpdateServersItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the SoftwareUpdateServersItem root element name to the wire value declared by the spec (<software_update_server>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type User 

type User struct {
	XMLName              xml.Name
	CustomPhotoURL       *string                   `xml:"custom_photo_url,omitempty"`
	Email                *string                   `xml:"email,omitempty"`
	EmailAddress         *string                   `xml:"email_address,omitempty"`
	EnableCustomPhotoURL *bool                     `xml:"enable_custom_photo_url,omitempty"`
	ExtensionAttributes  *UserExtensionAttributes2 `xml:"extension_attributes,omitempty"`
	FullName             *string                   `xml:"full_name,omitempty"`
	ID                   *int                      `xml:"id,omitempty"`
	LdapServer           *UserLdapServer           `xml:"ldap_server,omitempty"`
	Links                *UserLinks                `xml:"links,omitempty"`
	// Name of the user.
	Name        *string    `xml:"name,omitempty"`
	PhoneNumber *string    `xml:"phone_number,omitempty"`
	Position    *string    `xml:"position,omitempty"`
	Sites       *UserSites `xml:"sites,omitempty"`
}

User represents a user.

func (User) MarshalXML 

func (t User) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the User root element name to the wire value declared by the spec (<user>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserExtensionAttribute 

type UserExtensionAttribute struct {
	XMLName xml.Name
	// Allowed values: see the UserExtensionAttributeDataType constants.
	DataType    *string                          `xml:"data_type,omitempty"`
	Description *string                          `xml:"description,omitempty"`
	ID          *int                             `xml:"id,omitempty"`
	InputType   *UserExtensionAttributeInputType `xml:"input_type,omitempty"`
	// Name of the user extension attribute.
	Name *string `xml:"name,omitempty"`
}

UserExtensionAttribute represents a user extension attribute.

func (UserExtensionAttribute) MarshalXML 

func (t UserExtensionAttribute) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserExtensionAttribute root element name to the wire value declared by the spec (<user_extension_attribute>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserExtensionAttributeDataType 

type UserExtensionAttributeDataType = string

UserExtensionAttributeDataType is the set of values accepted by UserExtensionAttribute.DataType. 

const (
	UserExtensionAttributeDataTypeString  UserExtensionAttributeDataType = "String"
	UserExtensionAttributeDataTypeInteger UserExtensionAttributeDataType = "Integer"
	UserExtensionAttributeDataTypeDate    UserExtensionAttributeDataType = "Date"
)

UserExtensionAttributeDataType 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 UserExtensionAttributeDataTypeValues 

func UserExtensionAttributeDataTypeValues() []UserExtensionAttributeDataType

UserExtensionAttributeDataTypeValues returns every value the Jamf API accepts for UserExtensionAttributeDataType, 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 UserExtensionAttributeInputType 

type UserExtensionAttributeInputType struct {
	XMLName      xml.Name
	ID           *int                                         `xml:"id,omitempty"`
	PopupChoices *UserExtensionAttributeInputTypePopupChoices `xml:"popup_choices,omitempty"`
	// Allowed values: see the UserExtensionAttributeInputTypeType constants.
	Type *string `xml:"type,omitempty"`
}

UserExtensionAttributeInputType represents a user extension attribute input type.

func (UserExtensionAttributeInputType) MarshalXML 

func (t UserExtensionAttributeInputType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserExtensionAttributeInputType root element name to the wire value declared by the spec (<input_type>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserExtensionAttributeInputTypePopupChoices 

type UserExtensionAttributeInputTypePopupChoices struct {
	XMLName xml.Name
	Choice  *[]string `xml:"choice,omitempty"`
}

UserExtensionAttributeInputTypePopupChoices represents a user extension attribute input type popup choices.

func (UserExtensionAttributeInputTypePopupChoices) MarshalXML 

func (t UserExtensionAttributeInputTypePopupChoices) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserExtensionAttributeInputTypePopupChoices root element name to the wire value declared by the spec (<popup_choices>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserExtensionAttributeInputTypeType 

type UserExtensionAttributeInputTypeType = string

UserExtensionAttributeInputTypeType is the set of values accepted by UserExtensionAttributeInputType.Type. 

const (
	UserExtensionAttributeInputTypeTypeTextField UserExtensionAttributeInputTypeType = "Text Field"
	UserExtensionAttributeInputTypeTypePopUpMenu UserExtensionAttributeInputTypeType = "Pop-up Menu"
)

UserExtensionAttributeInputTypeType 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 UserExtensionAttributeInputTypeTypeValues 

func UserExtensionAttributeInputTypeTypeValues() []UserExtensionAttributeInputTypeType

UserExtensionAttributeInputTypeTypeValues returns every value the Jamf API accepts for UserExtensionAttributeInputTypeType, 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 UserExtensionAttributes 

type UserExtensionAttributes struct {
	XMLName                 xml.Name
	Size                    *Size    `xml:"size,omitempty"`
	UserExtensionAttributes []IDName `xml:"user_extension_attribute"`
}

UserExtensionAttributes wraps a Jamf Classic list response with a flat slice of IDName.

func (UserExtensionAttributes) MarshalXML 

func (t UserExtensionAttributes) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserExtensionAttributes root element name to the wire value declared by the spec (<user_extension_attributes>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserExtensionAttributes2 

type UserExtensionAttributes2 struct {
	XMLName            xml.Name
	ExtensionAttribute *[]UserExtensionAttributes2ExtensionAttributeItem `xml:"extension_attribute,omitempty"`
}

UserExtensionAttributes2 represents a user extension attributes2.

func (UserExtensionAttributes2) MarshalXML 

func (t UserExtensionAttributes2) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserExtensionAttributes2 root element name to the wire value declared by the spec (<extension_attributes>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserExtensionAttributes2ExtensionAttributeItem 

type UserExtensionAttributes2ExtensionAttributeItem struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
	// Allowed values: see the UserExtensionAttributes2ExtensionAttributeItemType constants.
	Type  *string `xml:"type,omitempty"`
	Value *string `xml:"value,omitempty"`
}

UserExtensionAttributes2ExtensionAttributeItem represents a user extension attributes2 extension attribute item.

func (UserExtensionAttributes2ExtensionAttributeItem) MarshalXML 

func (t UserExtensionAttributes2ExtensionAttributeItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserExtensionAttributes2ExtensionAttributeItem root element name to the wire value declared by the spec (<extension_attribute>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserExtensionAttributes2ExtensionAttributeItemType 

type UserExtensionAttributes2ExtensionAttributeItemType = string

UserExtensionAttributes2ExtensionAttributeItemType is the set of values accepted by UserExtensionAttributes2ExtensionAttributeItem.Type. 

const (
	UserExtensionAttributes2ExtensionAttributeItemTypeString  UserExtensionAttributes2ExtensionAttributeItemType = "String"
	UserExtensionAttributes2ExtensionAttributeItemTypeInteger UserExtensionAttributes2ExtensionAttributeItemType = "Integer"
	UserExtensionAttributes2ExtensionAttributeItemTypeDate    UserExtensionAttributes2ExtensionAttributeItemType = "Date"
)

UserExtensionAttributes2ExtensionAttributeItemType 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 UserExtensionAttributes2ExtensionAttributeItemTypeValues 

func UserExtensionAttributes2ExtensionAttributeItemTypeValues() []UserExtensionAttributes2ExtensionAttributeItemType

UserExtensionAttributes2ExtensionAttributeItemTypeValues returns every value the Jamf API accepts for UserExtensionAttributes2ExtensionAttributeItemType, 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 UserExtensionAttributesItem 

type UserExtensionAttributesItem struct {
	XMLName                xml.Name
	ID                     *int    `xml:"id,omitempty"`
	Size                   *Size   `xml:"size,omitempty"`
	UserExtensionAttribute *IDName `xml:"user_extension_attribute,omitempty"`
}

UserExtensionAttributesItem represents a user extension attributes item.

func (UserExtensionAttributesItem) MarshalXML 

func (t UserExtensionAttributesItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserExtensionAttributesItem root element name to the wire value declared by the spec (<user_extension_attribute>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserGroup 

type UserGroup struct {
	XMLName          xml.Name
	Criteria         *UserGroupCriteria `xml:"criteria,omitempty"`
	ID               *int               `xml:"id,omitempty"`
	IsNotifyOnChange *bool              `xml:"is_notify_on_change,omitempty"`
	IsSmart          *bool              `xml:"is_smart,omitempty"`
	// Name of the user group.
	Name  *string         `xml:"name,omitempty"`
	Site  *SiteObject     `xml:"site,omitempty"`
	Users *UserGroupUsers `xml:"users,omitempty"`
}

UserGroup represents a user group.

func (UserGroup) MarshalXML 

func (t UserGroup) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserGroup root element name to the wire value declared by the spec (<user_group>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserGroupCriteria 

type UserGroupCriteria struct {
	XMLName   xml.Name
	Criterion *[]Criterion `xml:"criterion,omitempty"`
	Size      *Size        `xml:"size,omitempty"`
}

UserGroupCriteria represents a user group criteria.

func (UserGroupCriteria) MarshalXML 

func (t UserGroupCriteria) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserGroupCriteria root element name to the wire value declared by the spec (<criteria>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserGroupUsers 

type UserGroupUsers struct {
	XMLName xml.Name
	Size    *Size                     `xml:"size,omitempty"`
	User    *[]UserGroupUsersUserItem `xml:"user,omitempty"`
}

UserGroupUsers represents a user group users.

func (UserGroupUsers) MarshalXML 

func (t UserGroupUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserGroupUsers root element name to the wire value declared by the spec (<users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserGroupUsersUserItem 

type UserGroupUsersUserItem struct {
	XMLName      xml.Name
	EmailAddress *string `xml:"email_address,omitempty"`
	FullName     *string `xml:"full_name,omitempty"`
	ID           *int    `xml:"id,omitempty"`
	PhoneNumber  *string `xml:"phone_number,omitempty"`
	Username     *string `xml:"username,omitempty"`
}

UserGroupUsersUserItem represents a user group users user item.

func (UserGroupUsersUserItem) MarshalXML 

func (t UserGroupUsersUserItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserGroupUsersUserItem root element name to the wire value declared by the spec (<user>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserGroups 

type UserGroups struct {
	XMLName    xml.Name
	Size       *Size                     `xml:"size,omitempty"`
	UserGroups []UserGroupsItemUserGroup `xml:"user_group"`
}

UserGroups wraps a Jamf Classic list response with a flat slice of UserGroupsItemUserGroup.

func (UserGroups) MarshalXML 

func (t UserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserGroups root element name to the wire value declared by the spec (<user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserGroupsItem 

type UserGroupsItem struct {
	XMLName   xml.Name
	ID        *int                     `xml:"id,omitempty"`
	Size      *Size                    `xml:"size,omitempty"`
	UserGroup *UserGroupsItemUserGroup `xml:"user_group,omitempty"`
}

UserGroupsItem represents a user groups item.

func (UserGroupsItem) MarshalXML 

func (t UserGroupsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserGroupsItem root element name to the wire value declared by the spec (<user_group>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserGroupsItemUserGroup 

type UserGroupsItemUserGroup struct {
	XMLName          xml.Name
	ID               *int  `xml:"id,omitempty"`
	IsNotifyOnChange *bool `xml:"is_notify_on_change,omitempty"`
	IsSmart          *bool `xml:"is_smart,omitempty"`
	// Name of the user group.
	Name *string `xml:"name,omitempty"`
}

UserGroupsItemUserGroup represents a user groups item user group.

func (UserGroupsItemUserGroup) MarshalXML 

func (t UserGroupsItemUserGroup) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserGroupsItemUserGroup root element name to the wire value declared by the spec (<user_group>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserLdapServer 

type UserLdapServer struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
}

UserLdapServer represents a user ldap server.

func (UserLdapServer) MarshalXML 

func (t UserLdapServer) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserLdapServer root element name to the wire value declared by the spec (<ldap_server>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding. 

type UserLinks struct {
	XMLName           xml.Name
	ID                *int                     `xml:"id,omitempty"`
	Computers         *UserLinksComputers      `xml:"computers,omitempty"`
	MobileDevices     *UserLinksMobileDevices  `xml:"mobile_devices,omitempty"`
	Peripherals       *UserLinksPeripherals    `xml:"peripherals,omitempty"`
	TotalVppCodeCount *int                     `xml:"total_vpp_code_count,omitempty"`
	VppAssignments    *UserLinksVppAssignments `xml:"vpp_assignments,omitempty"`
}

UserLinks represents a user links.

func (UserLinks) MarshalXML 

func (t UserLinks) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserLinks root element name to the wire value declared by the spec (<links>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserLinksComputers 

type UserLinksComputers struct {
	XMLName  xml.Name
	ID       *int    `xml:"id,omitempty"`
	Computer *IDName `xml:"computer,omitempty"`
}

UserLinksComputers represents a user links computers.

func (UserLinksComputers) MarshalXML 

func (t UserLinksComputers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserLinksComputers root element name to the wire value declared by the spec (<computers>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserLinksMobileDevices 

type UserLinksMobileDevices struct {
	XMLName      xml.Name
	ID           *int    `xml:"id,omitempty"`
	MobileDevice *IDName `xml:"mobile_device,omitempty"`
}

UserLinksMobileDevices represents a user links mobile devices.

func (UserLinksMobileDevices) MarshalXML 

func (t UserLinksMobileDevices) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserLinksMobileDevices root element name to the wire value declared by the spec (<mobile_devices>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserLinksPeripherals 

type UserLinksPeripherals struct {
	XMLName    xml.Name
	ID         *int    `xml:"id,omitempty"`
	Peripheral *IDName `xml:"peripheral,omitempty"`
}

UserLinksPeripherals represents a user links peripherals.

func (UserLinksPeripherals) MarshalXML 

func (t UserLinksPeripherals) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserLinksPeripherals root element name to the wire value declared by the spec (<peripherals>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserLinksVppAssignments 

type UserLinksVppAssignments struct {
	XMLName       xml.Name
	ID            *int    `xml:"id,omitempty"`
	VppAssignment *IDName `xml:"vpp_assignment,omitempty"`
}

UserLinksVppAssignments represents a user links vpp assignments.

func (UserLinksVppAssignments) MarshalXML 

func (t UserLinksVppAssignments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserLinksVppAssignments root element name to the wire value declared by the spec (<vpp_assignments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserPost 

type UserPost struct {
	XMLName              xml.Name
	CustomPhotoURL       *string                      `xml:"custom_photo_url,omitempty"`
	Email                *string                      `xml:"email,omitempty"`
	EmailAddress         *string                      `xml:"email_address,omitempty"`
	EnableCustomPhotoURL *bool                        `xml:"enable_custom_photo_url,omitempty"`
	ExtensionAttributes  *UserPostExtensionAttributes `xml:"extension_attributes,omitempty"`
	FullName             *string                      `xml:"full_name,omitempty"`
	ID                   *int                         `xml:"id,omitempty"`
	LdapServer           *UserPostLdapServer          `xml:"ldap_server,omitempty"`
	Links                *UserPostLinks               `xml:"links,omitempty"`
	// Name of the user.
	Name        *string        `xml:"name,omitempty"`
	PhoneNumber *string        `xml:"phone_number,omitempty"`
	Position    *string        `xml:"position,omitempty"`
	Sites       *UserPostSites `xml:"sites,omitempty"`
}

UserPost represents a user post.

func (UserPost) MarshalXML 

func (t UserPost) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserPost root element name to the wire value declared by the spec (<user>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserPostExtensionAttributes 

type UserPostExtensionAttributes struct {
	XMLName            xml.Name
	ExtensionAttribute *[]UserPostExtensionAttributesExtensionAttributeItem `xml:"extension_attribute,omitempty"`
}

UserPostExtensionAttributes represents a user post extension attributes.

func (UserPostExtensionAttributes) MarshalXML 

func (t UserPostExtensionAttributes) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserPostExtensionAttributes root element name to the wire value declared by the spec (<extension_attributes>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserPostExtensionAttributesExtensionAttributeItem 

type UserPostExtensionAttributesExtensionAttributeItem struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
	// Allowed values: see the UserPostExtensionAttributesExtensionAttributeItemType constants.
	Type  *string `xml:"type,omitempty"`
	Value *string `xml:"value,omitempty"`
}

UserPostExtensionAttributesExtensionAttributeItem represents a user post extension attributes extension attribute item.

func (UserPostExtensionAttributesExtensionAttributeItem) MarshalXML 

func (t UserPostExtensionAttributesExtensionAttributeItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserPostExtensionAttributesExtensionAttributeItem root element name to the wire value declared by the spec (<extension_attribute>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserPostExtensionAttributesExtensionAttributeItemType 

type UserPostExtensionAttributesExtensionAttributeItemType = string

UserPostExtensionAttributesExtensionAttributeItemType is the set of values accepted by UserPostExtensionAttributesExtensionAttributeItem.Type. 

const (
	UserPostExtensionAttributesExtensionAttributeItemTypeString  UserPostExtensionAttributesExtensionAttributeItemType = "String"
	UserPostExtensionAttributesExtensionAttributeItemTypeInteger UserPostExtensionAttributesExtensionAttributeItemType = "Integer"
	UserPostExtensionAttributesExtensionAttributeItemTypeDate    UserPostExtensionAttributesExtensionAttributeItemType = "Date"
)

UserPostExtensionAttributesExtensionAttributeItemType 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 UserPostExtensionAttributesExtensionAttributeItemTypeValues 

func UserPostExtensionAttributesExtensionAttributeItemTypeValues() []UserPostExtensionAttributesExtensionAttributeItemType

UserPostExtensionAttributesExtensionAttributeItemTypeValues returns every value the Jamf API accepts for UserPostExtensionAttributesExtensionAttributeItemType, 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 UserPostLdapServer 

type UserPostLdapServer struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Name    *string `xml:"name,omitempty"`
}

UserPostLdapServer represents a user post ldap server.

func (UserPostLdapServer) MarshalXML 

func (t UserPostLdapServer) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserPostLdapServer root element name to the wire value declared by the spec (<ldap_server>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding. 

type UserPostLinks struct {
	XMLName           xml.Name
	ID                *int                     `xml:"id,omitempty"`
	Computers         *UserLinksComputers      `xml:"computers,omitempty"`
	MobileDevices     *UserLinksMobileDevices  `xml:"mobile_devices,omitempty"`
	Peripherals       *UserLinksPeripherals    `xml:"peripherals,omitempty"`
	TotalVppCodeCount *int                     `xml:"total_vpp_code_count,omitempty"`
	VppAssignments    *UserLinksVppAssignments `xml:"vpp_assignments,omitempty"`
}

UserPostLinks represents a user post links.

func (UserPostLinks) MarshalXML 

func (t UserPostLinks) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserPostLinks root element name to the wire value declared by the spec (<links>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserPostSites 

type UserPostSites struct {
	XMLName xml.Name
	Site    *[]SiteObject `xml:"site,omitempty"`
}

UserPostSites represents a user post sites.

func (UserPostSites) MarshalXML 

func (t UserPostSites) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserPostSites root element name to the wire value declared by the spec (<sites>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UserSites 

type UserSites struct {
	XMLName xml.Name
	Site    *[]SiteObject `xml:"site,omitempty"`
}

UserSites represents a user sites.

func (UserSites) MarshalXML 

func (t UserSites) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UserSites root element name to the wire value declared by the spec (<sites>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Users 

type Users struct {
	XMLName xml.Name
	Size    *Size    `xml:"size,omitempty"`
	Users   []IDName `xml:"user"`
}

Users wraps a Jamf Classic list response with a flat slice of IDName.

func (Users) MarshalXML 

func (t Users) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Users root element name to the wire value declared by the spec (<users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type UsersItem 

type UsersItem struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Size    *Size   `xml:"size,omitempty"`
	User    *IDName `xml:"user,omitempty"`
}

UsersItem represents a users item.

func (UsersItem) MarshalXML 

func (t UsersItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the UsersItem root element name to the wire value declared by the spec (<user>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAccount 

type VppAccount struct {
	XMLName                  xml.Name
	AccountName              *string `xml:"account_name,omitempty"`
	AppleID                  *string `xml:"apple_id,omitempty"`
	AutoRegisterManagedUsers *bool   `xml:"auto_register_managed_users,omitempty"`
	Contact                  *string `xml:"contact,omitempty"`
	Country                  *string `xml:"country,omitempty"`
	ExpirationDate           *string `xml:"expiration_date,omitempty"`
	ID                       *int    `xml:"id,omitempty"`
	LocationName             *string `xml:"location_name,omitempty"`
	// Name of the VPP account.
	Name                          *string     `xml:"name,omitempty"`
	NotifyDisassociation          *bool       `xml:"notify_disassociation,omitempty"`
	PopulateCatalogFromVppContent *bool       `xml:"populate_catalog_from_vpp_content,omitempty"`
	ServiceToken                  *string     `xml:"service_token,omitempty"`
	Site                          *SiteObject `xml:"site,omitempty"`
}

VppAccount represents a vpp account.

func (VppAccount) MarshalXML 

func (t VppAccount) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAccount root element name to the wire value declared by the spec (<vpp_account>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAccounts 

type VppAccounts struct {
	XMLName     xml.Name
	Size        *Size    `xml:"size,omitempty"`
	VppAccounts []IDName `xml:"vpp_account"`
}

VppAccounts wraps a Jamf Classic list response with a flat slice of IDName.

func (VppAccounts) MarshalXML 

func (t VppAccounts) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAccounts root element name to the wire value declared by the spec (<vpp_accounts>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAccountsItem 

type VppAccountsItem struct {
	XMLName    xml.Name
	ID         *int    `xml:"id,omitempty"`
	Size       *Size   `xml:"size,omitempty"`
	VppAccount *IDName `xml:"vpp_account,omitempty"`
}

VppAccountsItem represents a vpp accounts item.

func (VppAccountsItem) MarshalXML 

func (t VppAccountsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAccountsItem root element name to the wire value declared by the spec (<vpp_account>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignment 

type VppAssignment struct {
	XMLName xml.Name
	ID      *int                  `xml:"id,omitempty"`
	Ebooks  *VppAssignmentEbooks  `xml:"ebooks,omitempty"`
	General *VppAssignmentGeneral `xml:"general,omitempty"`
	IosApps *VppAssignmentIosApps `xml:"ios_apps,omitempty"`
	MacApps *VppAssignmentMacApps `xml:"mac_apps,omitempty"`
	Scope   *VppAssignmentScope   `xml:"scope,omitempty"`
}

VppAssignment represents a vpp assignment.

func (VppAssignment) MarshalXML 

func (t VppAssignment) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignment root element name to the wire value declared by the spec (<vpp_assignment>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentEbooks 

type VppAssignmentEbooks struct {
	XMLName xml.Name
	Ebook   *[]VppAssignmentEbooksEbookItem `xml:"ebook,omitempty"`
}

VppAssignmentEbooks represents a vpp assignment ebooks.

func (VppAssignmentEbooks) MarshalXML 

func (t VppAssignmentEbooks) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentEbooks root element name to the wire value declared by the spec (<ebooks>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentEbooksEbookItem 

type VppAssignmentEbooksEbookItem struct {
	XMLName xml.Name
	AdamID  *int    `xml:"adam_id,omitempty"`
	Name    *string `xml:"name,omitempty"`
}

VppAssignmentEbooksEbookItem represents a vpp assignment ebooks ebook item.

func (VppAssignmentEbooksEbookItem) MarshalXML 

func (t VppAssignmentEbooksEbookItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentEbooksEbookItem root element name to the wire value declared by the spec (<ebook>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentGeneral 

type VppAssignmentGeneral struct {
	XMLName             xml.Name
	ID                  *int    `xml:"id,omitempty"`
	Name                *string `xml:"name,omitempty"`
	VppAdminAccountID   *int    `xml:"vpp_admin_account_id,omitempty"`
	VppAdminAccountName *string `xml:"vpp_admin_account_name,omitempty"`
}

VppAssignmentGeneral represents a vpp assignment general.

func (VppAssignmentGeneral) MarshalXML 

func (t VppAssignmentGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentIosApps 

type VppAssignmentIosApps struct {
	XMLName xml.Name
	IosApp  *[]VppAssignmentIosAppsIosAppItem `xml:"ios_app,omitempty"`
}

VppAssignmentIosApps represents a vpp assignment ios apps.

func (VppAssignmentIosApps) MarshalXML 

func (t VppAssignmentIosApps) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentIosApps root element name to the wire value declared by the spec (<ios_apps>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentIosAppsIosAppItem 

type VppAssignmentIosAppsIosAppItem struct {
	XMLName xml.Name
	AdamID  *int    `xml:"adam_id,omitempty"`
	Name    *string `xml:"name,omitempty"`
}

VppAssignmentIosAppsIosAppItem represents a vpp assignment ios apps ios app item.

func (VppAssignmentIosAppsIosAppItem) MarshalXML 

func (t VppAssignmentIosAppsIosAppItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentIosAppsIosAppItem root element name to the wire value declared by the spec (<ios_app>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentMacApps 

type VppAssignmentMacApps struct {
	XMLName xml.Name
	MacApp  *[]VppAssignmentMacAppsMacAppItem `xml:"mac_app,omitempty"`
}

VppAssignmentMacApps represents a vpp assignment mac apps.

func (VppAssignmentMacApps) MarshalXML 

func (t VppAssignmentMacApps) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentMacApps root element name to the wire value declared by the spec (<mac_apps>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentMacAppsMacAppItem 

type VppAssignmentMacAppsMacAppItem struct {
	XMLName xml.Name
	AdamID  *int    `xml:"adam_id,omitempty"`
	Name    *string `xml:"name,omitempty"`
}

VppAssignmentMacAppsMacAppItem represents a vpp assignment mac apps mac app item.

func (VppAssignmentMacAppsMacAppItem) MarshalXML 

func (t VppAssignmentMacAppsMacAppItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentMacAppsMacAppItem root element name to the wire value declared by the spec (<mac_app>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentPost 

type VppAssignmentPost struct {
	XMLName xml.Name
	ID      *int                      `xml:"id,omitempty"`
	Ebooks  *VppAssignmentPostEbooks  `xml:"ebooks,omitempty"`
	General *VppAssignmentPostGeneral `xml:"general,omitempty"`
	IosApps *VppAssignmentPostIosApps `xml:"ios_apps,omitempty"`
	MacApps *VppAssignmentPostMacApps `xml:"mac_apps,omitempty"`
	Scope   *VppAssignmentPostScope   `xml:"scope,omitempty"`
}

VppAssignmentPost represents a vpp assignment post.

func (VppAssignmentPost) MarshalXML 

func (t VppAssignmentPost) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentPost root element name to the wire value declared by the spec (<vpp_assignment>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentPostEbooks 

type VppAssignmentPostEbooks struct {
	XMLName xml.Name
	Ebook   *[]VppAssignmentPostEbooksEbookItem `xml:"ebook,omitempty"`
}

VppAssignmentPostEbooks represents a vpp assignment post ebooks.

func (VppAssignmentPostEbooks) MarshalXML 

func (t VppAssignmentPostEbooks) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentPostEbooks root element name to the wire value declared by the spec (<ebooks>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentPostEbooksEbookItem 

type VppAssignmentPostEbooksEbookItem struct {
	XMLName xml.Name
	AdamID  *int    `xml:"adam_id,omitempty"`
	Name    *string `xml:"name,omitempty"`
}

VppAssignmentPostEbooksEbookItem represents a vpp assignment post ebooks ebook item.

func (VppAssignmentPostEbooksEbookItem) MarshalXML 

func (t VppAssignmentPostEbooksEbookItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentPostEbooksEbookItem root element name to the wire value declared by the spec (<ebook>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentPostGeneral 

type VppAssignmentPostGeneral struct {
	XMLName             xml.Name
	ID                  *int    `xml:"id,omitempty"`
	Name                *string `xml:"name,omitempty"`
	VppAdminAccountID   *int    `xml:"vpp_admin_account_id,omitempty"`
	VppAdminAccountName *string `xml:"vpp_admin_account_name,omitempty"`
}

VppAssignmentPostGeneral represents a vpp assignment post general.

func (VppAssignmentPostGeneral) MarshalXML 

func (t VppAssignmentPostGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentPostGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentPostIosApps 

type VppAssignmentPostIosApps struct {
	XMLName xml.Name
	IosApp  *[]VppAssignmentPostIosAppsIosAppItem `xml:"ios_app,omitempty"`
}

VppAssignmentPostIosApps represents a vpp assignment post ios apps.

func (VppAssignmentPostIosApps) MarshalXML 

func (t VppAssignmentPostIosApps) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentPostIosApps root element name to the wire value declared by the spec (<ios_apps>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentPostIosAppsIosAppItem 

type VppAssignmentPostIosAppsIosAppItem struct {
	XMLName xml.Name
	AdamID  *int    `xml:"adam_id,omitempty"`
	Name    *string `xml:"name,omitempty"`
}

VppAssignmentPostIosAppsIosAppItem represents a vpp assignment post ios apps ios app item.

func (VppAssignmentPostIosAppsIosAppItem) MarshalXML 

func (t VppAssignmentPostIosAppsIosAppItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentPostIosAppsIosAppItem root element name to the wire value declared by the spec (<ios_app>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentPostMacApps 

type VppAssignmentPostMacApps struct {
	XMLName xml.Name
	MacApp  *[]VppAssignmentPostMacAppsMacAppItem `xml:"mac_app,omitempty"`
}

VppAssignmentPostMacApps represents a vpp assignment post mac apps.

func (VppAssignmentPostMacApps) MarshalXML 

func (t VppAssignmentPostMacApps) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentPostMacApps root element name to the wire value declared by the spec (<mac_apps>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentPostMacAppsMacAppItem 

type VppAssignmentPostMacAppsMacAppItem struct {
	XMLName xml.Name
	AdamID  *int    `xml:"adam_id,omitempty"`
	Name    *string `xml:"name,omitempty"`
}

VppAssignmentPostMacAppsMacAppItem represents a vpp assignment post mac apps mac app item.

func (VppAssignmentPostMacAppsMacAppItem) MarshalXML 

func (t VppAssignmentPostMacAppsMacAppItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentPostMacAppsMacAppItem root element name to the wire value declared by the spec (<mac_app>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentPostScope 

type VppAssignmentPostScope struct {
	XMLName       xml.Name
	ID            *int                             `xml:"id,omitempty"`
	AllJssUsers   *bool                            `xml:"all_jss_users,omitempty"`
	Exclusions    *VppAssignmentScopeExclusions    `xml:"exclusions,omitempty"`
	JssUserGroups *VppAssignmentScopeJssUserGroups `xml:"jss_user_groups,omitempty"`
	JssUsers      *VppAssignmentScopeJssUsers      `xml:"jss_users,omitempty"`
	Limitations   *VppAssignmentScopeLimitations   `xml:"limitations,omitempty"`
}

VppAssignmentPostScope represents a vpp assignment post scope.

func (VppAssignmentPostScope) MarshalXML 

func (t VppAssignmentPostScope) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentPostScope root element name to the wire value declared by the spec (<scope>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentScope 

type VppAssignmentScope struct {
	XMLName       xml.Name
	ID            *int                             `xml:"id,omitempty"`
	AllJssUsers   *bool                            `xml:"all_jss_users,omitempty"`
	Exclusions    *VppAssignmentScopeExclusions    `xml:"exclusions,omitempty"`
	JssUserGroups *VppAssignmentScopeJssUserGroups `xml:"jss_user_groups,omitempty"`
	JssUsers      *VppAssignmentScopeJssUsers      `xml:"jss_users,omitempty"`
	Limitations   *VppAssignmentScopeLimitations   `xml:"limitations,omitempty"`
}

VppAssignmentScope represents a vpp assignment scope.

func (VppAssignmentScope) MarshalXML 

func (t VppAssignmentScope) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentScope root element name to the wire value declared by the spec (<scope>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentScopeExclusions 

type VppAssignmentScopeExclusions struct {
	XMLName       xml.Name
	ID            *int                                       `xml:"id,omitempty"`
	JssUserGroups *VppAssignmentScopeExclusionsJssUserGroups `xml:"jss_user_groups,omitempty"`
	JssUsers      *VppAssignmentScopeExclusionsJssUsers      `xml:"jss_users,omitempty"`
	UserGroups    *VppAssignmentScopeExclusionsUserGroups    `xml:"user_groups,omitempty"`
}

VppAssignmentScopeExclusions represents a vpp assignment scope exclusions.

func (VppAssignmentScopeExclusions) MarshalXML 

func (t VppAssignmentScopeExclusions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentScopeExclusions root element name to the wire value declared by the spec (<exclusions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentScopeExclusionsJssUserGroups 

type VppAssignmentScopeExclusionsJssUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

VppAssignmentScopeExclusionsJssUserGroups represents a vpp assignment scope exclusions jss user groups.

func (VppAssignmentScopeExclusionsJssUserGroups) MarshalXML 

func (t VppAssignmentScopeExclusionsJssUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentScopeExclusionsJssUserGroups root element name to the wire value declared by the spec (<jss_user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentScopeExclusionsJssUsers 

type VppAssignmentScopeExclusionsJssUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

VppAssignmentScopeExclusionsJssUsers represents a vpp assignment scope exclusions jss users.

func (VppAssignmentScopeExclusionsJssUsers) MarshalXML 

func (t VppAssignmentScopeExclusionsJssUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentScopeExclusionsJssUsers root element name to the wire value declared by the spec (<jss_users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentScopeExclusionsUserGroups 

type VppAssignmentScopeExclusionsUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]VppAssignmentScopeExclusionsUserGroupsUserGroupItem `xml:"user_group,omitempty"`
}

VppAssignmentScopeExclusionsUserGroups represents a vpp assignment scope exclusions user groups.

func (VppAssignmentScopeExclusionsUserGroups) MarshalXML 

func (t VppAssignmentScopeExclusionsUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentScopeExclusionsUserGroups root element name to the wire value declared by the spec (<user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentScopeExclusionsUserGroupsUserGroupItem 

type VppAssignmentScopeExclusionsUserGroupsUserGroupItem struct {
	XMLName xml.Name
	Name    *string `xml:"name,omitempty"`
}

VppAssignmentScopeExclusionsUserGroupsUserGroupItem represents a vpp assignment scope exclusions user groups user group item.

func (VppAssignmentScopeExclusionsUserGroupsUserGroupItem) MarshalXML 

func (t VppAssignmentScopeExclusionsUserGroupsUserGroupItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentScopeExclusionsUserGroupsUserGroupItem root element name to the wire value declared by the spec (<user_group>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentScopeJssUserGroups 

type VppAssignmentScopeJssUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

VppAssignmentScopeJssUserGroups represents a vpp assignment scope jss user groups.

func (VppAssignmentScopeJssUserGroups) MarshalXML 

func (t VppAssignmentScopeJssUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentScopeJssUserGroups root element name to the wire value declared by the spec (<jss_user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentScopeJssUsers 

type VppAssignmentScopeJssUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

VppAssignmentScopeJssUsers represents a vpp assignment scope jss users.

func (VppAssignmentScopeJssUsers) MarshalXML 

func (t VppAssignmentScopeJssUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentScopeJssUsers root element name to the wire value declared by the spec (<jss_users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentScopeLimitations 

type VppAssignmentScopeLimitations struct {
	XMLName    xml.Name
	ID         *int                                     `xml:"id,omitempty"`
	UserGroups *VppAssignmentScopeLimitationsUserGroups `xml:"user_groups,omitempty"`
}

VppAssignmentScopeLimitations represents a vpp assignment scope limitations.

func (VppAssignmentScopeLimitations) MarshalXML 

func (t VppAssignmentScopeLimitations) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentScopeLimitations root element name to the wire value declared by the spec (<limitations>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentScopeLimitationsUserGroups 

type VppAssignmentScopeLimitationsUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

VppAssignmentScopeLimitationsUserGroups represents a vpp assignment scope limitations user groups.

func (VppAssignmentScopeLimitationsUserGroups) MarshalXML 

func (t VppAssignmentScopeLimitationsUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentScopeLimitationsUserGroups root element name to the wire value declared by the spec (<user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignments 

type VppAssignments struct {
	XMLName        xml.Name
	VppAssignments []VppAssignmentsItemVppAssignment `xml:"vpp_assignment"`
}

VppAssignments wraps a Jamf Classic list response with a flat slice of VppAssignmentsItemVppAssignment.

func (VppAssignments) MarshalXML 

func (t VppAssignments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignments root element name to the wire value declared by the spec (<vpp_assignments>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentsItem 

type VppAssignmentsItem struct {
	XMLName       xml.Name
	ID            *int                             `xml:"id,omitempty"`
	VppAssignment *VppAssignmentsItemVppAssignment `xml:"vpp_assignment,omitempty"`
}

VppAssignmentsItem represents a vpp assignments item.

func (VppAssignmentsItem) MarshalXML 

func (t VppAssignmentsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentsItem root element name to the wire value declared by the spec (<vpp_assignment>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppAssignmentsItemVppAssignment 

type VppAssignmentsItemVppAssignment struct {
	XMLName           xml.Name
	ID                *int    `xml:"id,omitempty"`
	Name              *string `xml:"name,omitempty"`
	VppAdminAccountID *int    `xml:"vpp_admin_account_id,omitempty"`
}

VppAssignmentsItemVppAssignment represents a vpp assignments item vpp assignment.

func (VppAssignmentsItemVppAssignment) MarshalXML 

func (t VppAssignmentsItemVppAssignment) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppAssignmentsItemVppAssignment root element name to the wire value declared by the spec (<vpp_assignment>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppInvitation 

type VppInvitation struct {
	XMLName          xml.Name
	ID               *int                           `xml:"id,omitempty"`
	General          *VppInvitationGeneral          `xml:"general,omitempty"`
	InvitationUsages *VppInvitationInvitationUsages `xml:"invitation_usages,omitempty"`
	Scope            *VppInvitationScope            `xml:"scope,omitempty"`
}

VppInvitation represents a vpp invitation.

func (VppInvitation) MarshalXML 

func (t VppInvitation) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppInvitation root element name to the wire value declared by the spec (<vpp_invitation>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppInvitationGeneral 

type VppInvitationGeneral struct {
	XMLName    xml.Name
	ID         *int                            `xml:"id,omitempty"`
	Name       *string                         `xml:"name,omitempty"`
	VppAccount *VppInvitationGeneralVppAccount `xml:"vpp_account,omitempty"`
	// Allowed values: see the VppInvitationGeneralDistributionMethod constants.
	DistributionMethod       *string `xml:"distribution_method,omitempty"`
	SenderName               *string `xml:"sender_name,omitempty"`
	SenderEmailAddress       *string `xml:"sender_email_address,omitempty"`
	Subject                  *string `xml:"subject,omitempty"`
	Message                  *string `xml:"message,omitempty"`
	RequireLogin             *bool   `xml:"require_login,omitempty"`
	AutoRegisterManagedUsers *bool   `xml:"auto_register_managed_users,omitempty"`
}

VppInvitationGeneral represents a vpp invitation general.

func (VppInvitationGeneral) MarshalXML 

func (t VppInvitationGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppInvitationGeneral root element name to the wire value declared by the spec (<general>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppInvitationGeneralDistributionMethod 

type VppInvitationGeneralDistributionMethod = string

VppInvitationGeneralDistributionMethod is the set of values accepted by VppInvitationGeneral.DistributionMethod. 

const (
	VppInvitationGeneralDistributionMethodPromptUsersToAcceptMakeAvailableInSelfService VppInvitationGeneralDistributionMethod = "Prompt users to accept/make available in Self Service"
	VppInvitationGeneralDistributionMethodSendEmails                                    VppInvitationGeneralDistributionMethod = "Send emails"
	VppInvitationGeneralDistributionMethodMakeAvailableInSelfServiceOnly                VppInvitationGeneralDistributionMethod = "Make available in Self Service only"
)

VppInvitationGeneralDistributionMethod 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 VppInvitationGeneralDistributionMethodValues 

func VppInvitationGeneralDistributionMethodValues() []VppInvitationGeneralDistributionMethod

VppInvitationGeneralDistributionMethodValues returns every value the Jamf API accepts for VppInvitationGeneralDistributionMethod, 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 VppInvitationGeneralVppAccount 

type VppInvitationGeneralVppAccount struct {
	XMLName xml.Name
	ID      *int `xml:"id,omitempty"`
}

VppInvitationGeneralVppAccount represents a vpp invitation general vpp account.

func (VppInvitationGeneralVppAccount) MarshalXML 

func (t VppInvitationGeneralVppAccount) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppInvitationGeneralVppAccount root element name to the wire value declared by the spec (<vpp_account>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppInvitationInvitationUsages 

type VppInvitationInvitationUsages struct {
	XMLName xml.Name
	Size    *Size                                     `xml:"size,omitempty"`
	Usage   *[]VppInvitationInvitationUsagesUsageItem `xml:"usage,omitempty"`
}

VppInvitationInvitationUsages represents a vpp invitation invitation usages.

func (VppInvitationInvitationUsages) MarshalXML 

func (t VppInvitationInvitationUsages) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppInvitationInvitationUsages root element name to the wire value declared by the spec (<invitation_usages>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppInvitationInvitationUsagesUsageItem 

type VppInvitationInvitationUsagesUsageItem struct {
	XMLName             xml.Name
	EmailAddress        *string `xml:"email_address,omitempty"`
	ID                  *int    `xml:"id,omitempty"`
	LastActionDateEpoch *int    `xml:"last_action_date_epoch,omitempty"`
	LastActionDateUtc   *string `xml:"last_action_date_utc,omitempty"`
	Name                *string `xml:"name,omitempty"`
	Status              *string `xml:"status,omitempty"`
	VppAccount          *string `xml:"vpp_account,omitempty"`
}

VppInvitationInvitationUsagesUsageItem represents a vpp invitation invitation usages usage item.

func (VppInvitationInvitationUsagesUsageItem) MarshalXML 

func (t VppInvitationInvitationUsagesUsageItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppInvitationInvitationUsagesUsageItem root element name to the wire value declared by the spec (<usage>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppInvitationScope 

type VppInvitationScope struct {
	XMLName       xml.Name
	ID            *int                             `xml:"id,omitempty"`
	AllJssUsers   *bool                            `xml:"all_jss_users,omitempty"`
	Exclusions    *VppInvitationScopeExclusions    `xml:"exclusions,omitempty"`
	JssUserGroups *VppInvitationScopeJssUserGroups `xml:"jss_user_groups,omitempty"`
	JssUsers      *VppInvitationScopeJssUsers      `xml:"jss_users,omitempty"`
	Limitations   *VppInvitationScopeLimitations   `xml:"limitations,omitempty"`
}

VppInvitationScope represents a vpp invitation scope.

func (VppInvitationScope) MarshalXML 

func (t VppInvitationScope) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppInvitationScope root element name to the wire value declared by the spec (<scope>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppInvitationScopeExclusions 

type VppInvitationScopeExclusions struct {
	XMLName       xml.Name
	ID            *int                                       `xml:"id,omitempty"`
	JssUserGroups *VppInvitationScopeExclusionsJssUserGroups `xml:"jss_user_groups,omitempty"`
	JssUsers      *VppInvitationScopeExclusionsJssUsers      `xml:"jss_users,omitempty"`
	UserGroups    *VppInvitationScopeExclusionsUserGroups    `xml:"user_groups,omitempty"`
}

VppInvitationScopeExclusions represents a vpp invitation scope exclusions.

func (VppInvitationScopeExclusions) MarshalXML 

func (t VppInvitationScopeExclusions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppInvitationScopeExclusions root element name to the wire value declared by the spec (<exclusions>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppInvitationScopeExclusionsJssUserGroups 

type VppInvitationScopeExclusionsJssUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

VppInvitationScopeExclusionsJssUserGroups represents a vpp invitation scope exclusions jss user groups.

func (VppInvitationScopeExclusionsJssUserGroups) MarshalXML 

func (t VppInvitationScopeExclusionsJssUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppInvitationScopeExclusionsJssUserGroups root element name to the wire value declared by the spec (<jss_user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppInvitationScopeExclusionsJssUsers 

type VppInvitationScopeExclusionsJssUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

VppInvitationScopeExclusionsJssUsers represents a vpp invitation scope exclusions jss users.

func (VppInvitationScopeExclusionsJssUsers) MarshalXML 

func (t VppInvitationScopeExclusionsJssUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppInvitationScopeExclusionsJssUsers root element name to the wire value declared by the spec (<jss_users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppInvitationScopeExclusionsUserGroups 

type VppInvitationScopeExclusionsUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]VppInvitationScopeExclusionsUserGroupsUserGroupItem `xml:"user_group,omitempty"`
}

VppInvitationScopeExclusionsUserGroups represents a vpp invitation scope exclusions user groups.

func (VppInvitationScopeExclusionsUserGroups) MarshalXML 

func (t VppInvitationScopeExclusionsUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppInvitationScopeExclusionsUserGroups root element name to the wire value declared by the spec (<user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppInvitationScopeExclusionsUserGroupsUserGroupItem 

type VppInvitationScopeExclusionsUserGroupsUserGroupItem struct {
	XMLName xml.Name
	Name    *string `xml:"name,omitempty"`
}

VppInvitationScopeExclusionsUserGroupsUserGroupItem represents a vpp invitation scope exclusions user groups user group item.

func (VppInvitationScopeExclusionsUserGroupsUserGroupItem) MarshalXML 

func (t VppInvitationScopeExclusionsUserGroupsUserGroupItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppInvitationScopeExclusionsUserGroupsUserGroupItem root element name to the wire value declared by the spec (<user_group>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppInvitationScopeJssUserGroups 

type VppInvitationScopeJssUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

VppInvitationScopeJssUserGroups represents a vpp invitation scope jss user groups.

func (VppInvitationScopeJssUserGroups) MarshalXML 

func (t VppInvitationScopeJssUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppInvitationScopeJssUserGroups root element name to the wire value declared by the spec (<jss_user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppInvitationScopeJssUsers 

type VppInvitationScopeJssUsers struct {
	XMLName xml.Name
	User    *[]IDName `xml:"user,omitempty"`
}

VppInvitationScopeJssUsers represents a vpp invitation scope jss users.

func (VppInvitationScopeJssUsers) MarshalXML 

func (t VppInvitationScopeJssUsers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppInvitationScopeJssUsers root element name to the wire value declared by the spec (<jss_users>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppInvitationScopeLimitations 

type VppInvitationScopeLimitations struct {
	XMLName    xml.Name
	ID         *int                                     `xml:"id,omitempty"`
	UserGroups *VppInvitationScopeLimitationsUserGroups `xml:"user_groups,omitempty"`
}

VppInvitationScopeLimitations represents a vpp invitation scope limitations.

func (VppInvitationScopeLimitations) MarshalXML 

func (t VppInvitationScopeLimitations) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppInvitationScopeLimitations root element name to the wire value declared by the spec (<limitations>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppInvitationScopeLimitationsUserGroups 

type VppInvitationScopeLimitationsUserGroups struct {
	XMLName   xml.Name
	UserGroup *[]IDName `xml:"user_group,omitempty"`
}

VppInvitationScopeLimitationsUserGroups represents a vpp invitation scope limitations user groups.

func (VppInvitationScopeLimitationsUserGroups) MarshalXML 

func (t VppInvitationScopeLimitationsUserGroups) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppInvitationScopeLimitationsUserGroups root element name to the wire value declared by the spec (<user_groups>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppInvitations 

type VppInvitations struct {
	XMLName        xml.Name
	Size           *Size    `xml:"size,omitempty"`
	VppInvitations []IDName `xml:"vpp_invitation"`
}

VppInvitations wraps a Jamf Classic list response with a flat slice of IDName.

func (VppInvitations) MarshalXML 

func (t VppInvitations) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppInvitations root element name to the wire value declared by the spec (<vpp_invitations>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type VppInvitationsItem 

type VppInvitationsItem struct {
	XMLName       xml.Name
	ID            *int    `xml:"id,omitempty"`
	Size          *Size   `xml:"size,omitempty"`
	VppInvitation *IDName `xml:"vpp_invitation,omitempty"`
}

VppInvitationsItem represents a vpp invitations item.

func (VppInvitationsItem) MarshalXML 

func (t VppInvitationsItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the VppInvitationsItem root element name to the wire value declared by the spec (<vpp_invitation>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type Webhook 

type Webhook struct {
	XMLName xml.Name
	// Allowed values: see the WebhookAuthenticationType constants.
	AuthenticationType *string `xml:"authentication_type,omitempty"`
	// Number of seconds to attempt to connect to the webhooks host server.
	ConnectionTimeout *int `xml:"connection_timeout,omitempty"`
	// Allowed values: see the WebhookContentType constants.
	ContentType                       *string               `xml:"content_type,omitempty"`
	DisplayFields                     *WebhookDisplayFields `xml:"display_fields,omitempty"`
	EnableDisplayFieldsForGroupObject *bool                 `xml:"enable_display_fields_for_group_object,omitempty"`
	Enabled                           *bool                 `xml:"enabled,omitempty"`
	// Allowed values: see the WebhookEvent constants.
	Event         *string `xml:"event,omitempty"`
	HashAlgorithm *string `xml:"hash_algorithm,omitempty"`
	Header        *string `xml:"header,omitempty"`
	ID            *int    `xml:"id,omitempty"`
	Name          *string `xml:"name,omitempty"`
	Password      *string `xml:"password,omitempty"`
	// Number of seconds to wait for a response from the webhooks host server after sending a request.
	ReadTimeout  *int    `xml:"read_timeout,omitempty"`
	SmartGroupID *int    `xml:"smart_group_id,omitempty"`
	URL          *string `xml:"url,omitempty"`
	Username     *string `xml:"username,omitempty"`
}

Webhook represents a webhook.

func (Webhook) MarshalXML 

func (t Webhook) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Webhook root element name to the wire value declared by the spec (<webhook>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type WebhookAuthenticationType 

type WebhookAuthenticationType = string

WebhookAuthenticationType is the set of values accepted by Webhook.AuthenticationType. 

const (
	WebhookAuthenticationTypeNone  WebhookAuthenticationType = "NONE"
	WebhookAuthenticationTypeBasic WebhookAuthenticationType = "BASIC"
)

WebhookAuthenticationType 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 WebhookAuthenticationTypeValues 

func WebhookAuthenticationTypeValues() []WebhookAuthenticationType

WebhookAuthenticationTypeValues returns every value the Jamf API accepts for WebhookAuthenticationType, 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 WebhookContentType 

type WebhookContentType = string

WebhookContentType is the set of values accepted by Webhook.ContentType. 

const (
	WebhookContentTypeTextXml         WebhookContentType = "text/xml"
	WebhookContentTypeApplicationJson WebhookContentType = "application/json"
)

WebhookContentType 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 WebhookContentTypeValues 

func WebhookContentTypeValues() []WebhookContentType

WebhookContentTypeValues returns every value the Jamf API accepts for WebhookContentType, 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 WebhookDisplayFields 

type WebhookDisplayFields struct {
	XMLName      xml.Name
	DisplayField *[]WebhookDisplayFieldsDisplayFieldItem `xml:"display_field,omitempty"`
	Size         *Size                                   `xml:"size,omitempty"`
}

WebhookDisplayFields represents a webhook display fields.

func (WebhookDisplayFields) MarshalXML 

func (t WebhookDisplayFields) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the WebhookDisplayFields root element name to the wire value declared by the spec (<display_fields>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type WebhookDisplayFieldsDisplayFieldItem 

type WebhookDisplayFieldsDisplayFieldItem struct {
	XMLName xml.Name
	// Name of the display field to include for smart group based webhook events.
	Name *string `xml:"name,omitempty"`
}

WebhookDisplayFieldsDisplayFieldItem represents a webhook display fields display field item.

func (WebhookDisplayFieldsDisplayFieldItem) MarshalXML 

func (t WebhookDisplayFieldsDisplayFieldItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the WebhookDisplayFieldsDisplayFieldItem root element name to the wire value declared by the spec (<display_field>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type WebhookEvent 

type WebhookEvent = string

WebhookEvent is the set of values accepted by Webhook.Event. 

const (
	WebhookEventComputerAdded                          WebhookEvent = "ComputerAdded"
	WebhookEventComputerCheckIn                        WebhookEvent = "ComputerCheckIn"
	WebhookEventComputerInventoryCompleted             WebhookEvent = "ComputerInventoryCompleted"
	WebhookEventComputerPolicyFinished                 WebhookEvent = "ComputerPolicyFinished"
	WebhookEventComputerPushCapabilityChanged          WebhookEvent = "ComputerPushCapabilityChanged"
	WebhookEventJSSShutdown                            WebhookEvent = "JSSShutdown"
	WebhookEventJSSStartup                             WebhookEvent = "JSSStartup"
	WebhookEventMobileDeviceCheckIn                    WebhookEvent = "MobileDeviceCheckIn"
	WebhookEventMobileDeviceCommandCompleted           WebhookEvent = "MobileDeviceCommandCompleted"
	WebhookEventMobileDeviceEnrolled                   WebhookEvent = "MobileDeviceEnrolled"
	WebhookEventMobileDevicePushSent                   WebhookEvent = "MobileDevicePushSent"
	WebhookEventMobileDeviceUnEnrolled                 WebhookEvent = "MobileDeviceUnEnrolled"
	WebhookEventPatchSoftwareTitleUpdated              WebhookEvent = "PatchSoftwareTitleUpdated"
	WebhookEventPushSent                               WebhookEvent = "PushSent"
	WebhookEventRestAPIOperation                       WebhookEvent = "RestAPIOperation"
	WebhookEventSCEPChallenge                          WebhookEvent = "SCEPChallenge"
	WebhookEventSmartGroupComputerMembershipChange     WebhookEvent = "SmartGroupComputerMembershipChange"
	WebhookEventSmartGroupMobileDeviceMembershipChange WebhookEvent = "SmartGroupMobileDeviceMembershipChange"
)

WebhookEvent 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 WebhookEventValues 

func WebhookEventValues() []WebhookEvent

WebhookEventValues returns every value the Jamf API accepts for WebhookEvent, 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 Webhooks 

type Webhooks struct {
	XMLName  xml.Name
	Size     *Size    `xml:"size,omitempty"`
	Webhooks []IDName `xml:"webhook"`
}

Webhooks wraps a Jamf Classic list response with a flat slice of IDName.

func (Webhooks) MarshalXML 

func (t Webhooks) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the Webhooks root element name to the wire value declared by the spec (<webhooks>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

type WebhooksItem 

type WebhooksItem struct {
	XMLName xml.Name
	ID      *int    `xml:"id,omitempty"`
	Size    *Size   `xml:"size,omitempty"`
	Webhook *IDName `xml:"webhook,omitempty"`
}

WebhooksItem represents a webhooks item.

func (WebhooksItem) MarshalXML 

func (t WebhooksItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML forces the WebhooksItem root element name to the wire value declared by the spec (<webhook>) regardless of what XMLName.Local holds. Classic resources are frequently decoded from polymorphic wire roots (<static_user_group>, <smart_user_group>, <user_group>, etc.) — stashing the incoming root name in XMLName is useful context but must not leak back into writes. The shadow type suppresses re-entry into this method during encoding.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.