jamfplatform

type APIResponseError = client.APIResponseError

type AmbiguousMatchError = client.AmbiguousMatchError

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

type ErrorDetail = client.Error

type Logger interface {
	LogRequest(ctx context.Context, method, url string, body []byte)
	LogResponse(ctx context.Context, statusCode int, headers http.Header, body []byte)
}

type MethodPrivileges struct {
	// Method is the generated Go method name, e.g. "CreateBuildingV1".
	Method string
	// HTTPMethod is the HTTP verb of the underlying endpoint, e.g. "POST".
	HTTPMethod string
	// Path is the endpoint's resource path relative to the tenant prefix,
	// e.g. "/buildings/{id}".
	Path string
	// Scopes lists the scope kinds the endpoint accepts. A client carries
	// exactly one scope, so a consumer needs a credential whose scope appears
	// here: ScopeTenant sends X-Tenant-Id, ScopeEnvironment sends
	// X-Environment-Id, and ScopeOrganization sends no header at all because
	// the gateway resolves the organization from the access token.
	//
	// Where two kinds are present the endpoint is published at both and the
	// caller picks one — the header must match the credential, and crossing
	// them over is 403 OWNERSHIP_FORBIDDEN even within one customer. So this
	// is an alternatives set, the opposite of Scoped, which is a conjunction.
	//
	// Where ScopesSource is "spec" this is the spec's own x-scope-types,
	// carried through unchanged; otherwise it is a correction this SDK
	// supplies for a spec that understates the gateway or declares no
	// extension at all. Read ScopesSource to tell the two apart. It is never
	// empty either way: a spec that declares no scope with no correction fails
	// generation rather than emitting an empty set a consumer would read as
	// "no scope required".
	//
	// Two caveats a consumer must not lose. A spec-sourced set is what the
	// spec declares, which is not always what the gateway serves: as of GitOps
	// v2082 the six Platform specs declare environment only, while devices,
	// device-groups, declaration-reporting and device-management-action still
	// answer under X-Tenant-Id (wire-verified 2026-09-04). And scope is
	// declared per spec rather than per operation, so every method built from
	// one spec carries the same set. The field is per-method as a precaution
	// against two specs in one package disagreeing — securitycloud did, one of
	// its six specs having been held at a build predating the others'
	// environment declaration, until v2082 was ingested there and closed the
	// gap. Keeping the field per-method means the next such divergence needs
	// no structural change.
	Scopes []ScopeKind
	// ScopesSource names where Scopes came from:
	//
	//   - "spec": the spec root's own x-scope-types extension.
	//   - "config-override": the SDK's own config.scopeTypes, because the
	//     published spec either understates what the gateway serves or
	//     declares no extension at all. One family is this case: the account
	//     trio (licensing, partners, sso) carries no x-scope-types in any
	//     published build and is organization-scoped by gateway
	//     configuration, the routes resolving the organization from the
	//     access token. securitycloud-device-groups was the second until
	//     2026-09-04, when the v2 update handler was fixed, its hold lifted
	//     and the ingested spec began declaring the set the override had been
	//     asserting — at which point the override self-expired, exactly as
	//     designed.
	//
	// A "config-override" entry is therefore an assertion about the gateway,
	// evidenced on the wire, rather than a claim about the ingested artifact —
	// the same distinction Source draws for Scoped. It is never empty: every
	// spec resolves a scope from one of the two sources or generation fails.
	ScopesSource string
	// Scoped lists the GA capability permissions the endpoint requires, in
	// {capability}:{action} form, e.g. "buildings:create". The capability is
	// kebab-case and carries no product name — one capability is reached by
	// endpoints across several products — and the action is one of exactly
	// six, lowercase and case-sensitive: create, read, update, delete,
	// deploy, execute. The three-part beta slug ("create:pro:buildings") is
	// the retired form and never appears here.
	//
	// Where more than one identifier is present, ALL of them are required.
	// The platform has exactly one route that accepts either of two
	// capabilities rather than both — DELETE /proclassic/logflush takes
	// flush-policy-logs:execute or policies:delete — and its specs declare
	// only the first, so no entry in this registry is an alternatives set. A
	// consumer can therefore render a multi-entry Scoped slice as "grant all
	// of these".
	//
	// An empty slice means nothing declares a privilege for the endpoint,
	// which is not the same as none being required. Most such endpoints are
	// genuinely unauthenticated — /v1/jamf-pro-version,
	// /v2/jamf-pro-information, the /v1/notifications list. A consumer
	// rendering a permissions table must not print an empty slice as "no
	// permission needed"; read Source to tell the two apart.
	Scoped []string
	// Source names where Scoped came from:
	//
	//   - "spec": the operation's own x-required-privileges extension.
	//   - "gateway-policy": the published spec declares none and the SDK
	//     supplies what the gateway's own authorization policy enforces. The
	//     account package's 18 methods are this case, and permanently so:
	//     these routes resolve the organization from the access token, which
	//     exempts them from the transform the publishing pipeline attaches
	//     x-required-privileges during, so the artifact ships without them by
	//     construction. The values come from
	//     the spec source repository's own per-team config.yaml
	//     and the hand-written OPA rules in
	//     the gateway's authorization policy for the account namespace,
	//     which agree on all 18.
	//   - "": Scoped is empty.
	//
	// Note for "gateway-policy": several account rules accept *either* the GA
	// capability recorded here or a retired read:org:*/update:org:* permission.
	// Only the GA form is carried, because Scoped is a conjunction and listing
	// the alternative would read as "both required".
	Source string
	// Legacy lists the human-readable Jamf Pro privilege names, e.g.
	// "Create Buildings". It is populated for the Pro API family only —
	// other families do not publish legacy names.
	//
	// Scoped and Legacy are INDEPENDENT SETS, not parallel arrays. Do not
	// match them by position, and do not assume equal length. Both are copied
	// in spec order.
	//
	// Two things make a positional pairing wrong, and each on its own is
	// sufficient (counts are pro at spec 11.31.0, 746 privileged operations):
	//
	//   - The lengths differ on 29 operations, because the GA capability
	//     consolidation mapped several legacy privileges onto one capability.
	//     GET /v1/computer-groups is Scoped ["device-groups:read"] against
	//     Legacy ["Read Smart Computer Groups", "Read Static Computer
	//     Groups"]. There is no bijection to zip.
	//   - Where the lengths do match, the orders still disagree, in the spec
	//     itself. POST /v1/jamf-management-framework/redeploy/{id} is Scoped
	//     ["computer-check-in:read", "device-actions:execute"] against Legacy
	//     ["Send Computer Remote Command to Install Package", "Read Computer
	//     Check-In"] — reversed. 9 of the 24 equal-length multi-privilege
	//     operations are like this.
	//
	// A consumer rendering a table of required privileges therefore has to
	// present the two lists separately, or label from Scoped alone. Jamf does
	// not publish the scoped-to-legacy mapping in the specs; its "Jamf Pro
	// permissions map" documentation article is the only artefact that carries
	// it, and until that is machine-readable a correct label per scoped
	// identifier cannot be derived here.
	Legacy []string
}

type Option func(*clientConfig)

type RSQLClause = client.RSQLClause

type ScopeKind = client.ScopeKind

type TokenCache interface {
	Load(key string) (token string, expiresAt time.Time, ok bool)
	Store(key string, token string, expiresAt time.Time) error
}