Documentation
¶
Index ¶
- Constants
- Variables
- func CleanupIntermediateFiles(outputDir string)
- func CollectDeviceGroupInfo(generatedFile string) (map[string]DeviceGroupInfo, error)
- func CountResources(generatedFile string) (map[string]int, error)
- func DefaultRules() []postprocess.ReferenceRule
- func DiscoverJamfConnect(ctx context.Context, pc *sdkpro.Client, outputDir string) (int, error)
- func ExtractSpecs() []postprocess.ExtractSpec
- func GenerateBrandingImages(ctx context.Context, pc *sdkpro.Client, generatedFile, outputDir string, ...) (int, error)
- func GenerateIcons(ctx context.Context, ig iconGetter, generatedFile string, ...) (int, error)
- func GenerateQueryFile(outputDir string, selectedResources map[string]bool) error
- func HydrateAppInstallerTitles(ctx context.Context, c appTitleLister, generatedFile, eventsFile string) (filled, guessed, unresolved int, err error)
- func MergeJamfProIDsFromEvents(info map[string]DeviceGroupInfo, eventsFile string) error
- func NormalizeSharedIpadActivationLock(generatedFile string) (int, error)
- func PopulateCriteriaNameIndexes(generatedFile string, reg *registry.Registry) error
- func PopulateDeviceGroupSubtypes(reg *registry.Registry, info map[string]DeviceGroupInfo) int
- func PopulateRegistryFromGenerated(generatedFile string, reg *registry.Registry) error
- func RenameLabels(generatedFile string) error
- func RequiredCapabilities(scope ScopeKind, selected map[string]bool, packageDownloads bool) []string
- func ResolveCriteriaExtensionAttributes(generatedFile string, reg *registry.Registry) (int, error)
- func ResourceTypeDisplayName(resourceType string) string
- func RunPipeline(opts *PipelineOptions) (*postprocess.FixResult, error)
- func StripComplianceBenchmarkArtifacts(generatedFile string, reg *registry.Registry) (int, error)
- func TypeToFileMap() map[string]string
- func ValidFilterNames() map[string]string
- func WritePermissionsFile(outputDir string, scope Scope, selected map[string]bool, packageDownloads bool) error
- func WriteSingletonImports(outputDir string, selectedResources map[string]bool) (bool, error)
- type DeviceGroupInfo
- type DiscoveredResource
- type IntermediateResult
- type Permission
- type PipelineOptions
- type ResourceDef
- type Scope
- type ScopeKind
- type ScopeSet
Constants ¶
const ( // DeviceGroup{Computer,Mobile}NameType resolve a device-group name (the value // of a "Computer Group" / "Mobile Device Group" member-of criterion) to a // jamfplatform_device_group address, scoped by device_type so a computer and a // mobile group sharing a name don't collide. DeviceGroupComputerNameType = "jamfplatform_device_group#name#computer" DeviceGroupMobileNameType = "jamfplatform_device_group#name#mobile" // {Computer,Mobile}EANameType resolve an extension-attribute name (used as a // device-group criterion field) to its EA resource address. ComputerEANameType = tComputerEA + "#name" MobileEANameType = tMobileEA + "#name" // UserGroupNameType resolves a user-group name to its resource address. A // user-group "User Group" member-of criterion carries the target group as // either its numeric ID or its name, depending on the tenant's Jamf Pro // version, so the rule tries the id-keyed type and this one in turn. UserGroupNameType = tUserGroup + "#name" )
Synthetic registry types keyed by NAME (not ID) for the name-based criteria references. Smart-group criteria reference other objects by name: device-group "member of" criteria carry the target group's name, and an extension-attribute criterion carries the EA's name as the criterion field itself.
const ( DeviceGroupComputerType = "jamfplatform_device_group#computer" DeviceGroupMobileType = "jamfplatform_device_group#mobile" )
Synthetic registry types used to disambiguate the two flavours of jamfplatform_device_group (one TF type, separate Jamf Pro ID spaces). They are keyed by jamf_pro_id and resolve to a jamfplatform_device_group.<label> address whose .jamf_pro_id is referenced from classic-API scope blocks.
Variables ¶
var Quiet bool
Quiet suppresses progress messages.
var Resources = buildResources()
Resources is the ordered list of all supported Jamf Platform resource types: native Platform Services resources, then federated Jamf Pro list resources, then federated Jamf Pro singleton settings.
Functions ¶
func CleanupIntermediateFiles ¶ added in v0.4.0
func CleanupIntermediateFiles(outputDir string)
CleanupIntermediateFiles removes the working files produced during discovery and generation once post-processing has split them into per-type files.
func CollectDeviceGroupInfo ¶ added in v0.4.0
func CollectDeviceGroupInfo(generatedFile string) (map[string]DeviceGroupInfo, error)
CollectDeviceGroupInfo reads the generated HCL and returns DeviceGroupInfo for every jamfplatform_device_group, keyed by its Platform UUID (the import-block identity id). DeviceType is read from the resource block (it is a Required attribute, so it is always present). JamfProID is read from the block too when the provider emitted it (it is computed, so usually absent — recover it via MergeJamfProIDsFromEvents).
func CountResources ¶
CountResources counts resource blocks by type in the generated file.
func DefaultRules ¶
func DefaultRules() []postprocess.ReferenceRule
DefaultRules returns the cross-resource reference rules for Jamf Platform. The federated jamfplatform_pro_* surface uses plugin-framework nested attributes (object expressions), so rules use AttrPath / ElementAttr rather than the block-based BlockPath used by the jamfpro provider.
func DiscoverJamfConnect ¶ added in v0.4.0
DiscoverJamfConnect lists the Jamf Connect config-profile links via the federated pro SDK and writes jamf_connect_import.tf with one import block per link (friendly label from the profile name, id = the config-profile id).
jamfplatform_pro_jamf_connect has no list resource — it adopts an existing macOS configuration profile that already carries a Jamf Connect payload — so it is not query-discoverable. The SDK enumerates the linked profiles; the subsequent `terraform plan -generate-config-out` materialises each resource's config from the import blocks written here (the same mechanism that handles the settings singletons). The import id is a passthrough of the config-profile id, which post-processing rewrites to a jamfplatform_pro_macos_configuration_profile reference (via the Numeric profile_id rule). Returns the number of import blocks written.
func ExtractSpecs ¶ added in v0.4.0
func ExtractSpecs() []postprocess.ExtractSpec
ExtractSpecs returns the string-attribute → support-file extraction specs for the federated Jamf Pro resources, whose content lives in plugin-framework nested attributes (object expressions).
func GenerateBrandingImages ¶ added in v0.4.0
func GenerateBrandingImages(ctx context.Context, pc *sdkpro.Client, generatedFile, outputDir string, reg *registry.Registry) (int, error)
GenerateBrandingImages synthesises jamfplatform_pro_self_service_branding_image resources from the branding-image ids referenced by the Self Service branding singletons. The branding-image store has no list resource (not query-discoverable), and the ids live on the already-materialised branding singletons. For every unique referenced id this downloads the image bytes via the federated pro SDK (`DownloadBrandingImageV1`), writes them to support_files/branding_images/, emits one resource (image_file_source = the local path, plus lifecycle ignore_changes since source_hash is ForceNew) and an import block keyed by the id, and registers the id so the singleton icon_id/banner_image_id references rewrite to the new resource (via the Numeric DefaultRules entries, since those attributes are number-typed). Returns the image count. Requires a tenant ID (pro endpoints are tenant-scoped).
func GenerateIcons ¶ added in v0.4.0
func GenerateIcons(ctx context.Context, ig iconGetter, generatedFile string, reg *registry.Registry) (int, error)
GenerateIcons synthesises jamfplatform_pro_icon resources from the self_service_icon references hydrated into policies. jamfplatform_pro_icon has no list resource, so icons are not query-discoverable; instead each policy's self_service_icon carries the icon's id (uri and filename are Computed-only, so `-generate-config-out` omits them; the uri is recovered via ig when the generated config lacks it). For every unique referenced icon this emits one jamfplatform_pro_icon resource whose icon_file_source is the CDN uri (the provider downloads + re-uploads it) plus an import block keyed by the icon id, registers the icon id so the self_service_icon.id reference can be rewritten to the new resource, and drops the server-computed uri/filename echoes from each policy's self_service_icon (they would otherwise drift on a fresh tenant). Returns the icon count.
An icon whose uri cannot be resolved (ig is nil, or the lookup fails) is not emitted: icon_file_source is Required and an empty string would be turned into an unsettable variable. Its policy references stay as the raw icon id.
func GenerateQueryFile ¶
GenerateQueryFile writes a .tfquery.hcl file with list blocks for selected listable resource types. If selectedResources is nil, all listable resource types are included. List blocks are emitted in Resources-table order for deterministic output.
func HydrateAppInstallerTitles ¶ added in v0.6.0
func HydrateAppInstallerTitles(ctx context.Context, c appTitleLister, generatedFile, eventsFile string) (filled, guessed, unresolved int, err error)
HydrateAppInstallerTitles fills in app_title_name on every jamfplatform_pro_app_installer block that the provider read back as null.
The provider marks app_title_name Required but its list resource returns null for it, so the generated block cannot plan — `terraform query` exits non-zero and, without this, an App Installer on the tenant would fail the whole export. The deployment's app_title_id is in the query event stream, so the name is resolved from the App Installers catalogue, which is the same place the provider should be resolving it.
Where that chain breaks — the catalogue read fails, the title has been withdrawn from the catalogue since the deployment was created, or the provider did not surface the computed app_title_id in the event payload — the deployment's own name is used as a fallback: Jamf Pro defaults a deployment's name to the title name, so it is usually right and is always better than a null the provider rejects outright.
"Usually right" is not "right", though, and a wrong app_title_name names a different app than the object the block imports. So the three outcomes are counted separately rather than summed: filled is a title the catalogue (or an app_title_name the provider actually returned) answered for, guessed is a title taken from the deployment name, and unresolved counts blocks that needed a title and got none — those keep their null for the validation pass to report. Callers are expected to surface guessed and unresolved rather than presenting the total as resolved.
A missing events file is not an error, and neither is an unreachable catalogue: both degrade into guessed/unresolved counts.
func MergeJamfProIDsFromEvents ¶ added in v0.4.0
func MergeJamfProIDsFromEvents(info map[string]DeviceGroupInfo, eventsFile string) error
MergeJamfProIDsFromEvents fills in JamfProID (and DeviceType, if missing) on the device group info map from a terraform query -json event log. jamf_pro_id is a computed attribute that `-generate-config-out` drops, so it can only be recovered from the query event stream (when the provider surfaces it) or a direct API call. Missing data leaves JamfProID empty and is not an error.
func NormalizeSharedIpadActivationLock ¶ added in v0.4.0
NormalizeSharedIpadActivationLock sets prevent_activation_lock = true on any mobile_device_prestage_enrollment with multi_user = true (Shared iPad).
This is not a value the admin can choose: when Shared iPad is enabled the Jamf Pro UI auto-checks "Prevent user from enabling Activation Lock" and disables the control, and the API rejects a write of the pair with `400 PREREQUISITE_NOT_MET: "Prevent activation lock needs to be enabled in order to enable Shared iPad"` (wire-confirmed by creating a dummy prestage). So true is the only value Jamf permits for a Shared iPad prestage — the provider validates this and rejects false.
A prestage can still be *read back* with prevent_activation_lock = false if it was created before Jamf added the prerequisite (legacy data). Exporting that stale false verbatim produces a config that neither validates nor applies, so we normalize it to the canonical, Jamf-enforced value (matching what the UI shows and what the server requires). Returns the number of prestages adjusted.
func PopulateCriteriaNameIndexes ¶ added in v0.4.0
PopulateCriteriaNameIndexes registers name→address entries used by the name-based criteria reference rules: device-group names per device_type, computer/mobile extension-attribute names, and user-group names. Addresses come straight from the resource block labels in the generated HCL.
func PopulateDeviceGroupSubtypes ¶ added in v0.4.0
func PopulateDeviceGroupSubtypes(reg *registry.Registry, info map[string]DeviceGroupInfo) int
PopulateDeviceGroupSubtypes registers each device group under a synthetic registry type — jamfplatform_device_group#computer or jamfplatform_device_group#mobile — keyed by its Jamf Pro numeric ID and mapping to the real jamfplatform_device_group.<label> address. Classic scope rules resolve computer_group_ids / mobile_device_group_ids against these subtypes and reference .jamf_pro_id. Entries without a recoverable JamfProID are skipped (scope references to them stay as TODO).
Returns the number of device groups that could not be bridged (no JamfProID), so the caller can warn the user.
func PopulateRegistryFromGenerated ¶
PopulateRegistryFromGenerated parses a generated HCL file and populates the registry with resource type + ID -> address mappings. IDs are extracted from import blocks (which use "identity { id = ... }" for query-generated imports, or flat "id = ..." for singleton imports).
func RenameLabels ¶
RenameLabels rewrites auto-generated labels (like "all_0") in the generated HCL file to friendly names derived from resource attributes, folding device_type into jamfplatform_device_group labels to avoid computer/mobile collisions.
func RequiredCapabilities ¶ added in v0.6.0
func RequiredCapabilities(scope ScopeKind, selected map[string]bool, packageDownloads bool) []string
RequiredCapabilities returns the union of read capabilities needed to export the given selection, sorted. A nil selection means every resource type reachable at the given scope. packageDownloads reports whether the run downloads package files, which reads the JCDS file store on top of the package catalogue. The result is the permission set to tick in Jamf Account's picker for an integration that only has to run this export.
func ResolveCriteriaExtensionAttributes ¶ added in v0.4.0
ResolveCriteriaExtensionAttributes rewrites a device group's smart-group criterion field (the `criteria` attribute of each criteria element) to a jamfplatform_pro_*_extension_attribute.<x>.name reference when it names a known EA for the group's device_type. Built-in criteria (e.g. "Application Bundle ID") don't match any EA name and are left untouched. Returns the number of device-group resources whose criteria were modified.
Device-group member-of values and user-group member-of values are handled by the DefaultRules discriminator engine; only the EA-name-as-criterion-field case needs the owning resource's device_type, so it lives here.
func ResourceTypeDisplayName ¶
ResourceTypeDisplayName returns a human-readable name for a resource type.
func RunPipeline ¶
func RunPipeline(opts *PipelineOptions) (*postprocess.FixResult, error)
RunPipeline executes the full Jamf Platform export pipeline: generate provider config → query file → terraform init → terraform query → post-process. Returns the validation fix result (may be nil) and any fatal error.
func StripComplianceBenchmarkArtifacts ¶ added in v0.4.0
StripComplianceBenchmarkArtifacts removes benchmark-derived resources (and their import blocks) from the generated config, deregistering them so that any reference from a kept resource falls back to a raw ID instead of a dangling address. It returns the number of resource blocks removed.
func TypeToFileMap ¶
TypeToFileMap returns a map of TF resource type → output filename, derived from the Resources table.
func ValidFilterNames ¶
ValidFilterNames returns a map of user-friendly filter names → canonical keys.
func WritePermissionsFile ¶ added in v0.6.0
func WritePermissionsFile(outputDir string, scope Scope, selected map[string]bool, packageDownloads bool) error
WritePermissionsFile writes PERMISSIONS.md into the output directory: the capability set the export required, and a per-resource breakdown. It ships with the generated project so the next person to run the export — or to apply it in CI — can create an integration with the right permissions instead of over-granting to make an unattributed 403 go away. packageDownloads reports whether the run fetched package files, which reads the JCDS file store under its own capability; a -skip-package-downloads run must not claim it.
func WriteSingletonImports ¶ added in v0.4.0
WriteSingletonImports writes singletons_import.tf with an import block per selected singleton settings resource (label "singleton", identity id "singleton"), so a subsequent `terraform plan -generate-config-out` can materialise their config. Returns false if no singleton import blocks were written.
The identity form (`identity = { id = "singleton" }`) is used rather than the flat `id = "singleton"`, for two reasons. It is what `plan -generate-config-out` emits itself, so the blocks jamformer writes match the ones it reads back. And on the flat form a singleton that is not configured on the tenant reports a framework-level "Missing Resource Identity After Read", which tells the user to report a provider bug: `ImportState` populates state before `Read` runs, so `Read` cannot tell an import from a refresh, takes the refresh path for a missing object and returns no identity. The identity form leaves state null, which `Read` recognises, and an unconfigured singleton reports plainly that there is nothing to import.
Types ¶
type DeviceGroupInfo ¶ added in v0.4.0
type DeviceGroupInfo struct {
Address string // e.g. "jamfplatform_device_group.engineering_computer"
DeviceType string // "computer" | "mobile"
JamfProID string // classic numeric ID; empty when not recoverable
}
DeviceGroupInfo carries the data needed to bridge a jamfplatform_device_group to classic-API scope references. A device group is a single TF type covering both computer and mobile groups (distinguished by DeviceType), each with its own Jamf Pro numeric ID space (JamfProID).
type DiscoveredResource ¶ added in v0.4.0
type DiscoveredResource struct {
TFType string // e.g. "jamfplatform_pro_policy"
Label string // e.g. "install_chrome"
Name string // human-readable Jamf name (falls back to the label)
JamfID string // import ID; empty if no import block was found
}
DiscoveredResource is a flat (type, label, name, id) record for a single resource, used by the multi-env merge pipeline to match resources across environments by (type, label) and to write per-env import blocks.
func CollectResourceRefs ¶ added in v0.4.0
func CollectResourceRefs(generatedFile string, importFiles ...string) ([]DiscoveredResource, error)
CollectResourceRefs enumerates the discovered resources from the generated HCL by joining each resource block with its import block. List-resource import blocks live inside generatedFile (terraform query format, identity = { id = "..." }); singleton and jamf_connect import blocks live in the supplied importFiles (flat id = "..."). Resource labels and import "to" addresses are consistent after RenameLabels, so the join is by address.
A resource with no matching import block is still returned, with an empty JamfID (it gets no per-env import block but still participates in matching).
type IntermediateResult ¶ added in v0.4.0
type IntermediateResult struct {
Registry *registry.Registry
GeneratedFile string // path to generated.tf (import + resource blocks still present)
OutputDir string // working directory
PackageFiles map[string]string // JCDS file_name → relative path
Resources []DiscoveredResource // flat (type, label, name, id) list for multi-env matching
PlatformCreds *importgen.PlatformCredentials
ProviderSchemas any // *tfjson.ProviderSchemas (kept as interface to avoid import in callers)
}
IntermediateResult holds the output of RunDiscoveryAndGenerate — everything needed to either run the standard single-env postprocessing or feed into the multi-env merge pipeline. Mirrors pro.IntermediateResult.
func RunDiscoveryAndGenerate ¶ added in v0.4.0
func RunDiscoveryAndGenerate(opts *PipelineOptions) (*IntermediateResult, error)
RunDiscoveryAndGenerate executes steps 1–6 of the Jamf Platform pipeline (generate config → init → query → jamf_connect/singleton/icon/branding synthesis → package download → schema load) and returns the intermediate results without post-processing. generated.tf is left in place — carrying every import block, including the singleton and Jamf Connect ones folded in from their own files — so callers can both post-process it and enumerate the discovered resources. Used by both the single-env RunPipeline and the multi-env merge pipeline.
type Permission ¶ added in v0.6.0
type Permission struct {
// Capability is the GA capability permission in {capability}:{action}
// form, e.g. "device-groups:read". This is what an integration grants.
Capability string
// Legacy is the retired Jamf Pro privilege name, e.g. "Read Buildings".
// Populated for the Jamf Pro family only; other families publish none.
Legacy []string
// Scopes are the scope kinds the backing endpoint accepts.
Scopes []jamfplatform.ScopeKind
// Method and Path identify the endpoint the requirement came from, so a
// reader can check the claim rather than take it on trust.
Method string
Path string
}
Permission is one resolved permission requirement for a resource type.
func ResourcePermissions ¶ added in v0.6.0
func ResourcePermissions(filterKey string) ([]Permission, string)
ResourcePermissions returns the read permissions an export of this resource type requires, de-duplicated and sorted by capability. The key is a filter key for a type in the Resources table, or a TF type for one of the synthetic types, which have no filter key. The second return is a reason when no permission could be resolved: either the type is deliberately unmapped (see unmappedReads) or the SDK declares no privilege for its endpoint, which is NOT the same as none being required.
type PipelineOptions ¶
type PipelineOptions struct {
OutputDir string
BaseURL string
ClientID string
ClientSecret string
// Scope is the API integration's scope. It decides which construct
// families are reachable, which header the provider sends, and whether the
// federated Jamf Pro surface (packages, Jamf Connect, branding images) can
// be reached at all.
Scope Scope
SelectedResources map[string]bool
SkipReferences bool
SkipPackageDownloads bool
SplitByCategory bool
ProviderVersion string
Quiet bool
Verbose bool
StatusFunc func(string, int, int) // optional callback: (message, current, total)
}
PipelineOptions holds all parameters needed to run the Jamf Platform pipeline.
type ResourceDef ¶
type ResourceDef struct {
FilterKey string // key for -include-resources / -exclude-resources
DisplayName string // human-readable name for prompts and output
TFType string // Terraform resource type name
OutputFile string // filename in the output directory
IsSingleton bool // true for tenant-wide settings imported by a fixed ID
SingletonImportID string // import ID for singletons (e.g. "singleton")
Scopes ScopeSet // API integration scopes this resource is reachable at
}
ResourceDef describes a single Jamf Platform resource type.
func ListableResources ¶ added in v0.4.0
func ListableResources() []ResourceDef
ListableResources returns the resource defs discoverable via `terraform query` (everything that is not a singleton).
func ResourcesForScope ¶ added in v0.6.0
func ResourcesForScope(k ScopeKind) []ResourceDef
ResourcesForScope returns the resource defs reachable under the given scope, in Resources-table order. Everything else is unreachable with the configured credentials: the provider refuses it at configure time, so querying it would fail the whole run rather than skip one type.
func SingletonResources ¶ added in v0.4.0
func SingletonResources() []ResourceDef
SingletonResources returns the tenant-wide settings resource defs.
func UnreachableForScope ¶ added in v0.6.0
func UnreachableForScope(k ScopeKind) []ResourceDef
UnreachableForScope returns the resource defs the given scope cannot reach, so a run can report what it is skipping and why rather than silently exporting less than the user asked for.
type Scope ¶ added in v0.6.0
Scope is the resolved scope for a run: its kind plus the identifier the gateway is given (empty for organization scope).
func ResolveScope ¶ added in v0.6.0
ResolveScope determines the run's scope from explicit values, falling back to the environment. Both jamformer's own JAMF_* names and the provider's own JAMFPLATFORM_* names are accepted, so credentials already exported for `terraform` work unchanged; the JAMF_* name wins where both are set.
The two identifiers are mutually exclusive, matching the provider, which rejects both together with a "Conflicting API Integration Scope" error. Supplying neither selects organization scope, which is how the provider itself selects it. JAMFPLATFORM_ORGANIZATION_ID is accepted as an explicit way to ask for organization scope: it is not a provider attribute and is never sent, but naming it beats leaving the choice implicit in the absence of two other variables.
func (Scope) EnvironmentID ¶ added in v0.6.0
EnvironmentID returns the environment ID, or "" when the scope is not an environment scope.
func (Scope) ReachesPro ¶ added in v0.6.0
ReachesPro reports whether this scope reaches the federated Jamf Pro surface. The pro endpoints are published at both environment and tenant scope, so everything but organization scope reaches them. Package downloads, Jamf Connect discovery and Self Service branding images all depend on this.
type ScopeKind ¶ added in v0.6.0
type ScopeKind int
ScopeKind is the scope an API integration was registered with. It decides which construct families the credentials can reach, and which HTTP header the provider (and the SDK) sends to identify the caller's target.
The Jamf Platform API reached GA on 3 September 2026. Scope now travels in a request header rather than a URL path, and three kinds exist. An integration carries exactly one: it is chosen at registration in Jamf Account and cannot be changed afterwards.
const ( // ScopeEnvironment targets a "Platform environment" — a group of tenants // across product types. It sends X-Environment-Id. This is the preferred // scope for new integrations and the only one that reaches Blueprints, // Compliance Benchmarks and AI Governance. ScopeEnvironment ScopeKind = iota // ScopeTenant targets a single Jamf Pro / Jamf School / Jamf Protect / // Jamf Security Cloud tenant. It sends X-Tenant-Id. Legacy: it costs one // integration per tenant per product, and cannot reach Blueprints, // Compliance Benchmarks or AI Governance at all. ScopeTenant // ScopeOrganization targets the Jamf Account organization. It sends no // scope header at all — the gateway resolves the organization from the // access token — and is selected by supplying neither an environment nor a // tenant ID. It is the only scope that reaches jamfplatform_account_*, and // reaches nothing else. ScopeOrganization )
func (ScopeKind) ProviderAttr ¶ added in v0.6.0
ProviderAttr returns the provider attribute that selects this scope, or "" for organization scope, which is selected by setting neither attribute.
type ScopeSet ¶ added in v0.6.0
type ScopeSet uint8
ScopeSet is the set of scope kinds a resource type is reachable at. A run reaches the resource when its own scope is a member.
const ( // ScopeSetEnvOnly marks a family only an environment-scoped integration // reaches: Blueprints, Compliance Benchmarks, AI Governance. The provider // refuses these at configure time under any other scope. ScopeSetEnvOnly ScopeSet = 1 << iota // ScopeSetTenantOrEnv marks a family reachable under either environment or // tenant scope: the federated Jamf Pro surface, Jamf Security Cloud, and // the Platform inventory constructs (device groups included). ScopeSetTenantOrEnv // ScopeSetOrgOnly marks the Jamf Account family, which only an // organization-scoped integration reaches — and which is the only family // that scope reaches. ScopeSetOrgOnly )
Source Files
¶
Directories
¶
| Path | Synopsis |
|---|---|
|
Package download fetches package files for the Jamf Platform pipeline from the Jamf Cloud Distribution Service (JCDS) via the federated Jamf Platform gateway.
|
Package download fetches package files for the Jamf Platform pipeline from the Jamf Cloud Distribution Service (JCDS) via the federated Jamf Platform gateway. |