@axonflow/sdk 9.1.0 → 9.3.0

package/dist/esm/types/authzen.gen.js

@@ -0,0 +1,779 @@
+/**
+ * AuthZEN wire types and validators. GENERATED FILE — DO NOT EDIT.
+ *
+ * Source: tests/fixtures/authzen-surface.json
+ *   artifact:        axonflow-authzen-surface v1
+ *   profile:         axonflow-authzen-profile-2026-08-29
+ *   contract schema: 2026-08-29
+ *   schema digest:   sha256:04f63f4d97215faa9fbf2b6a5152630f7310edbe47440b975d0f66ad63df811f
+ *
+ * Regenerate with:
+ *
+ *   node scripts/gen-authzen-types/generate.js
+ *
+ * Editing this file by hand is pointless: tests/authzen-generator.test.ts
+ * regenerates it in memory and compares bytes, so a hand edit fails CI on the
+ * next run.
+ */
+// The profile a Policy Enforcement Point negotiates to receive anything beyond the
+// boolean decision. AuthZEN 1.0's response is a bare boolean; the four-valued state,
+// the obligations, the approval challenge and the safe reason code all ride in the
+// response context and are returned ONLY to a caller that asked for them by version.
+export const AUTHZEN_PROFILE_V1 = 'axonflow-authzen-profile-2026-08-29';
+// The contract version these types were generated from. It is the value the server
+// echoes in AuthZENResponseContext.schema_version.
+export const AUTHZEN_CONTRACT_SCHEMA_VERSION = '2026-08-29';
+// The one route the AuthZEN surface is served on, and the request header the profile
+// is negotiated with. Both are generated from the platform's contract through the
+// artifact, not written here: a rename on the platform is a regenerate-and-diff
+// failure in this SDK, not a 404 in production (axonflow-enterprise#3603).
+export const AUTHZEN_PATH = '/api/v1/access/evaluation';
+export const AUTHZEN_PROFILE_HEADER = 'X-Axonflow-AuthZEN-Profile';
+// The digest of the JSON Schema the artifact was reduced from. It is carried so a
+// support conversation can establish which contract a deployed SDK was built against
+// without reading its dependency tree.
+export const AUTHZEN_SOURCE_SCHEMA_SHA256 = 'sha256:04f63f4d97215faa9fbf2b6a5152630f7310edbe47440b975d0f66ad63df811f';
+/**
+ * Raised when a value does not match the AuthZEN contract. The message always
+ * names a JSON Pointer, because on this surface the pointer IS the diagnosis:
+ * "unsupported_subject" without the offending member is a puzzle.
+ */
+export class AuthZENSchemaError extends Error {
+    constructor(pointer, detail) {
+        super(`${pointer || '/'} ${detail}`);
+        this.name = 'AuthZENSchemaError';
+        this.pointer = pointer;
+        Object.setPrototypeOf(this, AuthZENSchemaError.prototype);
+    }
+}
+export function authzenFail(pointer, detail) {
+    throw new AuthZENSchemaError(pointer, detail);
+}
+export function authzenObject(value, at) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        authzenFail(at, 'must be an object');
+    }
+    return { ...value };
+}
+export function authzenString(value, at) {
+    if (typeof value !== 'string') {
+        authzenFail(at, 'must be a string');
+    }
+    return value;
+}
+export function authzenBoolean(value, at) {
+    if (typeof value !== 'boolean') {
+        authzenFail(at, 'must be a boolean');
+    }
+    return value;
+}
+// An integer, not merely a number. The artifact distinguishes them, and a
+// fractional schema_version is not a schema_version.
+export function authzenInteger(value, at) {
+    if (typeof value !== 'number' || !Number.isInteger(value)) {
+        authzenFail(at, 'must be an integer');
+    }
+    return value;
+}
+export function authzenArray(value, at) {
+    if (!Array.isArray(value)) {
+        authzenFail(at, 'must be an array');
+    }
+    return value;
+}
+/**
+ * Refuse a member the contract does not declare.
+ *
+ * On the RESPONSE path this is the whole strictness argument: a member this
+ * build has never heard of means the server is speaking a profile it cannot
+ * fully read, and dropping it silently would mean acting on a partial reading
+ * of an authorization decision. On the REQUEST path it catches a member the
+ * caller invented before it becomes a 422.
+ */
+export function authzenNoExtraMembers(obj, at, known) {
+    const extra = Object.keys(obj)
+        .filter(key => !known.includes(key))
+        .sort();
+    if (extra.length > 0) {
+        authzenFail(at, `carries members this build does not understand: ${extra.join(', ')}`);
+    }
+}
+export const AUTHZEN_ERROR_CODE_MALFORMED_ENVELOPE = 'malformed_envelope';
+export const AUTHZEN_ERROR_CODE_INCOMPLETE_EVALUATION = 'incomplete_evaluation';
+export const AUTHZEN_ERROR_CODE_UNSUPPORTED_SUBJECT = 'unsupported_subject';
+export const AUTHZEN_ERROR_CODE_UNSUPPORTED_ACTION = 'unsupported_action';
+export const AUTHZEN_ERROR_CODE_UNSUPPORTED_RESOURCE = 'unsupported_resource';
+export const AUTHZEN_ERROR_CODE_UNEVALUABLE_ATTRIBUTE = 'unevaluable_attribute';
+export const AUTHZEN_ERROR_CODE_MISSING_EVALUABLE_CONTENT = 'missing_evaluable_content';
+export const AUTHZEN_ERROR_CODE_EVALUATION_UNAVAILABLE = 'evaluation_unavailable';
+// Every value of authzen_error_code this build knows, in the artifact's order.
+export const AUTHZEN_ERROR_CODE_VALUES = [
+    AUTHZEN_ERROR_CODE_MALFORMED_ENVELOPE,
+    AUTHZEN_ERROR_CODE_INCOMPLETE_EVALUATION,
+    AUTHZEN_ERROR_CODE_UNSUPPORTED_SUBJECT,
+    AUTHZEN_ERROR_CODE_UNSUPPORTED_ACTION,
+    AUTHZEN_ERROR_CODE_UNSUPPORTED_RESOURCE,
+    AUTHZEN_ERROR_CODE_UNEVALUABLE_ATTRIBUTE,
+    AUTHZEN_ERROR_CODE_MISSING_EVALUABLE_CONTENT,
+    AUTHZEN_ERROR_CODE_EVALUATION_UNAVAILABLE,
+];
+export const AUTHZEN_CATEGORY_ALLOWED = 'allowed';
+export const AUTHZEN_CATEGORY_NOT_PERMITTED = 'not_permitted';
+export const AUTHZEN_CATEGORY_APPROVAL_REQUIRED = 'approval_required';
+export const AUTHZEN_CATEGORY_TEMPORARILY_UNAVAILABLE = 'temporarily_unavailable';
+export const AUTHZEN_CATEGORY_INVALID_REQUEST = 'invalid_request';
+// Every value of category this build knows, in the artifact's order.
+export const AUTHZEN_CATEGORY_VALUES = [
+    AUTHZEN_CATEGORY_ALLOWED,
+    AUTHZEN_CATEGORY_NOT_PERMITTED,
+    AUTHZEN_CATEGORY_APPROVAL_REQUIRED,
+    AUTHZEN_CATEGORY_TEMPORARILY_UNAVAILABLE,
+    AUTHZEN_CATEGORY_INVALID_REQUEST,
+];
+export const AUTHZEN_IDENTIFIER_KIND_ORGANIZATION = 'organization';
+export const AUTHZEN_IDENTIFIER_KIND_PRINCIPAL = 'principal';
+export const AUTHZEN_IDENTIFIER_KIND_GROUP = 'group';
+export const AUTHZEN_IDENTIFIER_KIND_RESOURCE = 'resource';
+export const AUTHZEN_IDENTIFIER_KIND_ACTION = 'action';
+export const AUTHZEN_IDENTIFIER_KIND_TOOL = 'tool';
+export const AUTHZEN_IDENTIFIER_KIND_CLIENT = 'client';
+export const AUTHZEN_IDENTIFIER_KIND_SESSION = 'session';
+// Every value of identifier_kind this build knows, in the artifact's order.
+export const AUTHZEN_IDENTIFIER_KIND_VALUES = [
+    AUTHZEN_IDENTIFIER_KIND_ORGANIZATION,
+    AUTHZEN_IDENTIFIER_KIND_PRINCIPAL,
+    AUTHZEN_IDENTIFIER_KIND_GROUP,
+    AUTHZEN_IDENTIFIER_KIND_RESOURCE,
+    AUTHZEN_IDENTIFIER_KIND_ACTION,
+    AUTHZEN_IDENTIFIER_KIND_TOOL,
+    AUTHZEN_IDENTIFIER_KIND_CLIENT,
+    AUTHZEN_IDENTIFIER_KIND_SESSION,
+];
+export const AUTHZEN_OBLIGATION_TYPE_APPROVAL_CHALLENGE = 'approval_challenge';
+export const AUTHZEN_OBLIGATION_TYPE_FIELD_REMOVE = 'field_remove';
+export const AUTHZEN_OBLIGATION_TYPE_FIELD_REDACT = 'field_redact';
+export const AUTHZEN_OBLIGATION_TYPE_FIELD_HASH = 'field_hash';
+export const AUTHZEN_OBLIGATION_TYPE_FIELD_MASK = 'field_mask';
+export const AUTHZEN_OBLIGATION_TYPE_FIELD_ANNOTATE = 'field_annotate';
+export const AUTHZEN_OBLIGATION_TYPE_FIELD_TOKENIZE = 'field_tokenize';
+export const AUTHZEN_OBLIGATION_TYPE_SCHEMA_TRANSFORM = 'schema_transform';
+export const AUTHZEN_OBLIGATION_TYPE_RESPONSE_FILTER = 'response_filter';
+export const AUTHZEN_OBLIGATION_TYPE_ROUTE_RESTRICTION = 'route_restriction';
+export const AUTHZEN_OBLIGATION_TYPE_STEP_UP_AUTHENTICATION = 'step_up_authentication';
+export const AUTHZEN_OBLIGATION_TYPE_QUOTA_RESERVATION = 'quota_reservation';
+export const AUTHZEN_OBLIGATION_TYPE_IMMUTABLE_AUDIT = 'immutable_audit';
+export const AUTHZEN_OBLIGATION_TYPE_NOTIFICATION = 'notification';
+// Every value of obligation_type this build knows, in the artifact's order.
+export const AUTHZEN_OBLIGATION_TYPE_VALUES = [
+    AUTHZEN_OBLIGATION_TYPE_APPROVAL_CHALLENGE,
+    AUTHZEN_OBLIGATION_TYPE_FIELD_REMOVE,
+    AUTHZEN_OBLIGATION_TYPE_FIELD_REDACT,
+    AUTHZEN_OBLIGATION_TYPE_FIELD_HASH,
+    AUTHZEN_OBLIGATION_TYPE_FIELD_MASK,
+    AUTHZEN_OBLIGATION_TYPE_FIELD_ANNOTATE,
+    AUTHZEN_OBLIGATION_TYPE_FIELD_TOKENIZE,
+    AUTHZEN_OBLIGATION_TYPE_SCHEMA_TRANSFORM,
+    AUTHZEN_OBLIGATION_TYPE_RESPONSE_FILTER,
+    AUTHZEN_OBLIGATION_TYPE_ROUTE_RESTRICTION,
+    AUTHZEN_OBLIGATION_TYPE_STEP_UP_AUTHENTICATION,
+    AUTHZEN_OBLIGATION_TYPE_QUOTA_RESERVATION,
+    AUTHZEN_OBLIGATION_TYPE_IMMUTABLE_AUDIT,
+    AUTHZEN_OBLIGATION_TYPE_NOTIFICATION,
+];
+export const AUTHZEN_OPERATIONAL_STATE_ALLOW = 'ALLOW';
+export const AUTHZEN_OPERATIONAL_STATE_DENY = 'DENY';
+export const AUTHZEN_OPERATIONAL_STATE_CHALLENGE = 'CHALLENGE';
+export const AUTHZEN_OPERATIONAL_STATE_ERROR = 'ERROR';
+// Every value of operational_state this build knows, in the artifact's order.
+export const AUTHZEN_OPERATIONAL_STATE_VALUES = [
+    AUTHZEN_OPERATIONAL_STATE_ALLOW,
+    AUTHZEN_OPERATIONAL_STATE_DENY,
+    AUTHZEN_OPERATIONAL_STATE_CHALLENGE,
+    AUTHZEN_OPERATIONAL_STATE_ERROR,
+];
+export const AUTHZEN_REASON_CODE_PERMITTED = 'permitted';
+export const AUTHZEN_REASON_CODE_APPROVAL_REQUIRED = 'approval_required';
+export const AUTHZEN_REASON_CODE_EXPLICIT_CONSTRAINT = 'explicit_constraint';
+export const AUTHZEN_REASON_CODE_NO_MATCHING_PERMISSION = 'no_matching_permission';
+export const AUTHZEN_REASON_CODE_UNKNOWN_CONSTRAINT = 'unknown_constraint';
+export const AUTHZEN_REASON_CODE_UNKNOWN_PERMISSION = 'unknown_permission';
+export const AUTHZEN_REASON_CODE_UNKNOWN_REQUIREMENT = 'unknown_requirement';
+export const AUTHZEN_REASON_CODE_INVALID_INPUT = 'invalid_input';
+export const AUTHZEN_REASON_CODE_EVALUATION_ERROR = 'evaluation_error';
+export const AUTHZEN_REASON_CODE_UNSUPPORTED_OBLIGATION = 'unsupported_obligation';
+export const AUTHZEN_REASON_CODE_OBLIGATION_CONFLICT = 'obligation_conflict';
+export const AUTHZEN_REASON_CODE_UNKNOWN_ACTION = 'unknown_action';
+export const AUTHZEN_REASON_CODE_UNKNOWN_REALM = 'unknown_realm';
+export const AUTHZEN_REASON_CODE_SCHEMA_VIOLATION = 'schema_violation';
+export const AUTHZEN_REASON_CODE_DELEGATION_DEPTH_EXCEEDED = 'delegation_depth_exceeded';
+export const AUTHZEN_REASON_CODE_BUDGET_EXHAUSTED = 'budget_exhausted';
+export const AUTHZEN_REASON_CODE_BINDING_MISMATCH = 'binding_mismatch';
+export const AUTHZEN_REASON_CODE_APPROVAL_UNSATISFIABLE = 'approval_unsatisfiable';
+export const AUTHZEN_REASON_CODE_APPROVAL_EXPIRED = 'approval_expired';
+export const AUTHZEN_REASON_CODE_AUTHORING_REJECTED = 'authoring_rejected';
+// Every value of reason_code this build knows, in the artifact's order.
+export const AUTHZEN_REASON_CODE_VALUES = [
+    AUTHZEN_REASON_CODE_PERMITTED,
+    AUTHZEN_REASON_CODE_APPROVAL_REQUIRED,
+    AUTHZEN_REASON_CODE_EXPLICIT_CONSTRAINT,
+    AUTHZEN_REASON_CODE_NO_MATCHING_PERMISSION,
+    AUTHZEN_REASON_CODE_UNKNOWN_CONSTRAINT,
+    AUTHZEN_REASON_CODE_UNKNOWN_PERMISSION,
+    AUTHZEN_REASON_CODE_UNKNOWN_REQUIREMENT,
+    AUTHZEN_REASON_CODE_INVALID_INPUT,
+    AUTHZEN_REASON_CODE_EVALUATION_ERROR,
+    AUTHZEN_REASON_CODE_UNSUPPORTED_OBLIGATION,
+    AUTHZEN_REASON_CODE_OBLIGATION_CONFLICT,
+    AUTHZEN_REASON_CODE_UNKNOWN_ACTION,
+    AUTHZEN_REASON_CODE_UNKNOWN_REALM,
+    AUTHZEN_REASON_CODE_SCHEMA_VIOLATION,
+    AUTHZEN_REASON_CODE_DELEGATION_DEPTH_EXCEEDED,
+    AUTHZEN_REASON_CODE_BUDGET_EXHAUSTED,
+    AUTHZEN_REASON_CODE_BINDING_MISMATCH,
+    AUTHZEN_REASON_CODE_APPROVAL_UNSATISFIABLE,
+    AUTHZEN_REASON_CODE_APPROVAL_EXPIRED,
+    AUTHZEN_REASON_CODE_AUTHORING_REJECTED,
+];
+/**
+ * Validate an unknown value as AuthZENApprovalClause, or throw naming the member at
+ * fault. Unknown members are REFUSED rather than dropped: on the response path an
+ * unrecognised member is a server speaking a profile this build does not understand,
+ * and quietly ignoring it would mean acting on a partial reading of an authorization
+ * decision.
+ */
+export function validateAuthZENApprovalClause(value, at) {
+    const obj = authzenObject(value, at);
+    authzenNoExtraMembers(obj, at, ['quorum', 'eligible']);
+    if (obj['quorum'] === undefined || obj['quorum'] === null) {
+        authzenFail(`${at}/quorum`, 'is required');
+    }
+    else {
+        authzenInteger(obj['quorum'], `${at}/quorum`);
+    }
+    if (obj['eligible'] === undefined || obj['eligible'] === null) {
+        authzenFail(`${at}/eligible`, 'is required');
+    }
+    else {
+        const items = authzenArray(obj['eligible'], `${at}/eligible`);
+        if (items.length < 1) {
+            authzenFail(`${at}/eligible`, 'needs at least 1 entry');
+        }
+        obj['eligible'] = items.map((item, index) => validateAuthZENIdentifier(item, `${`${at}/eligible`}/${index}`));
+    }
+    return obj;
+}
+/**
+ * Validate an unknown value as AuthZENApprovalRequirement, or throw naming the member
+ * at fault. Unknown members are REFUSED rather than dropped: on the response path an
+ * unrecognised member is a server speaking a profile this build does not understand,
+ * and quietly ignoring it would mean acting on a partial reading of an authorization
+ * decision.
+ */
+export function validateAuthZENApprovalRequirement(value, at) {
+    const obj = authzenObject(value, at);
+    authzenNoExtraMembers(obj, at, ['all_of', 'separation_of_duties', 'expires_at']);
+    if (obj['all_of'] === undefined || obj['all_of'] === null) {
+        authzenFail(`${at}/all_of`, 'is required');
+    }
+    else {
+        const items = authzenArray(obj['all_of'], `${at}/all_of`);
+        if (items.length < 1) {
+            authzenFail(`${at}/all_of`, 'needs at least 1 entry');
+        }
+        obj['all_of'] = items.map((item, index) => validateAuthZENApprovalClause(item, `${`${at}/all_of`}/${index}`));
+    }
+    if (obj['separation_of_duties'] === undefined || obj['separation_of_duties'] === null) {
+        authzenFail(`${at}/separation_of_duties`, 'is required');
+    }
+    else {
+        authzenBoolean(obj['separation_of_duties'], `${at}/separation_of_duties`);
+    }
+    if (obj['expires_at'] === undefined || obj['expires_at'] === null) {
+        authzenFail(`${at}/expires_at`, 'is required');
+    }
+    else {
+        authzenString(obj['expires_at'], `${at}/expires_at`);
+    }
+    return obj;
+}
+/**
+ * Validate an unknown value as AuthZENAction, or throw naming the member at fault.
+ * Unknown members are REFUSED rather than dropped: on the response path an
+ * unrecognised member is a server speaking a profile this build does not understand,
+ * and quietly ignoring it would mean acting on a partial reading of an authorization
+ * decision.
+ */
+export function validateAuthZENAction(value, at) {
+    const obj = authzenObject(value, at);
+    authzenNoExtraMembers(obj, at, ['name', 'properties']);
+    if (obj['name'] === undefined || obj['name'] === null) {
+        authzenFail(`${at}/name`, 'is required');
+    }
+    else {
+        const raw = authzenString(obj['name'], `${at}/name`);
+        if (raw.length < 1) {
+            authzenFail(`${at}/name`, 'must be at least 1 character(s); it is present but too short');
+        }
+    }
+    if (obj['properties'] === undefined || obj['properties'] === null) {
+        delete obj['properties'];
+    }
+    else {
+        authzenObject(obj['properties'], `${at}/properties`);
+    }
+    return obj;
+}
+/**
+ * Validate an unknown value as AuthZENBulk, or throw naming the member at fault.
+ * Unknown members are REFUSED rather than dropped: on the response path an
+ * unrecognised member is a server speaking a profile this build does not understand,
+ * and quietly ignoring it would mean acting on a partial reading of an authorization
+ * decision.
+ */
+export function validateAuthZENBulk(value, at) {
+    const obj = authzenObject(value, at);
+    authzenNoExtraMembers(obj, at, ['subject', 'action', 'resource', 'context', 'evaluations']);
+    if (obj['subject'] === undefined || obj['subject'] === null) {
+        delete obj['subject'];
+    }
+    else {
+        obj['subject'] = validateAuthZENSubject(obj['subject'], `${at}/subject`);
+    }
+    if (obj['action'] === undefined || obj['action'] === null) {
+        delete obj['action'];
+    }
+    else {
+        obj['action'] = validateAuthZENAction(obj['action'], `${at}/action`);
+    }
+    if (obj['resource'] === undefined || obj['resource'] === null) {
+        delete obj['resource'];
+    }
+    else {
+        obj['resource'] = validateAuthZENResource(obj['resource'], `${at}/resource`);
+    }
+    if (obj['context'] === undefined || obj['context'] === null) {
+        delete obj['context'];
+    }
+    else {
+        authzenObject(obj['context'], `${at}/context`);
+    }
+    if (obj['evaluations'] === undefined || obj['evaluations'] === null) {
+        authzenFail(`${at}/evaluations`, 'is required');
+    }
+    else {
+        const items = authzenArray(obj['evaluations'], `${at}/evaluations`);
+        if (items.length < 1) {
+            authzenFail(`${at}/evaluations`, 'needs at least 1 entry');
+        }
+        obj['evaluations'] = items.map((item, index) => validateAuthZENRequest(item, `${`${at}/evaluations`}/${index}`));
+    }
+    return obj;
+}
+/**
+ * Validate an unknown value as AuthZENEnvelope, or throw naming the member at fault.
+ * Unknown members are REFUSED rather than dropped: on the response path an
+ * unrecognised member is a server speaking a profile this build does not understand,
+ * and quietly ignoring it would mean acting on a partial reading of an authorization
+ * decision.
+ */
+export function validateAuthZENEnvelope(value, at) {
+    const obj = authzenObject(value, at);
+    authzenNoExtraMembers(obj, at, ['evaluation', 'evaluations']);
+    if (obj['evaluation'] === undefined || obj['evaluation'] === null) {
+        delete obj['evaluation'];
+    }
+    else {
+        obj['evaluation'] = validateAuthZENRequest(obj['evaluation'], `${at}/evaluation`);
+    }
+    if (obj['evaluations'] === undefined || obj['evaluations'] === null) {
+        delete obj['evaluations'];
+    }
+    else {
+        obj['evaluations'] = validateAuthZENBulk(obj['evaluations'], `${at}/evaluations`);
+    }
+    {
+        const set = [obj['evaluation'] !== undefined, obj['evaluations'] !== undefined].filter(Boolean).length;
+        if (set !== 1) {
+            authzenFail(at, `exactly one of evaluation or evaluations must be set, ${set} are`);
+        }
+    }
+    if (obj['evaluation'] !== undefined) {
+        const nested = obj['evaluation'];
+        if (nested['action'] === undefined || nested['action'] === null) {
+            authzenFail(`${at}/evaluation`, 'has no action; it has no shared base to inherit one from');
+        }
+    }
+    if (obj['evaluation'] !== undefined) {
+        const nested = obj['evaluation'];
+        if (nested['resource'] === undefined || nested['resource'] === null) {
+            authzenFail(`${at}/evaluation`, 'has no resource; it has no shared base to inherit one from');
+        }
+    }
+    if (obj['evaluation'] !== undefined) {
+        const nested = obj['evaluation'];
+        if (nested['subject'] === undefined || nested['subject'] === null) {
+            authzenFail(`${at}/evaluation`, 'has no subject; it has no shared base to inherit one from');
+        }
+    }
+    return obj;
+}
+/**
+ * Validate an unknown value as AuthZENError, or throw naming the member at fault.
+ * Unknown members are REFUSED rather than dropped: on the response path an
+ * unrecognised member is a server speaking a profile this build does not understand,
+ * and quietly ignoring it would mean acting on a partial reading of an authorization
+ * decision.
+ */
+export function validateAuthZENError(value, at) {
+    const obj = authzenObject(value, at);
+    authzenNoExtraMembers(obj, at, ['code', 'pointer', 'message', 'supported', 'request_id']);
+    if (obj['code'] === undefined || obj['code'] === null) {
+        authzenFail(`${at}/code`, 'is required');
+    }
+    else {
+        authzenString(obj['code'], `${at}/code`);
+    }
+    if (obj['pointer'] === undefined || obj['pointer'] === null) {
+        delete obj['pointer'];
+    }
+    else {
+        authzenString(obj['pointer'], `${at}/pointer`);
+    }
+    if (obj['message'] === undefined || obj['message'] === null) {
+        authzenFail(`${at}/message`, 'is required');
+    }
+    else {
+        const raw = authzenString(obj['message'], `${at}/message`);
+        if (raw.length < 1) {
+            authzenFail(`${at}/message`, 'must be at least 1 character(s); it is present but too short');
+        }
+    }
+    if (obj['supported'] === undefined || obj['supported'] === null) {
+        delete obj['supported'];
+    }
+    else {
+        const items = authzenArray(obj['supported'], `${at}/supported`);
+        items.forEach((item, index) => {
+            authzenString(item, `${`${at}/supported`}/${index}`);
+        });
+    }
+    if (obj['request_id'] === undefined || obj['request_id'] === null) {
+        delete obj['request_id'];
+    }
+    else {
+        authzenString(obj['request_id'], `${at}/request_id`);
+    }
+    return obj;
+}
+/**
+ * Validate an unknown value as AuthZENRequest, or throw naming the member at fault.
+ * Unknown members are REFUSED rather than dropped: on the response path an
+ * unrecognised member is a server speaking a profile this build does not understand,
+ * and quietly ignoring it would mean acting on a partial reading of an authorization
+ * decision.
+ */
+export function validateAuthZENRequest(value, at) {
+    const obj = authzenObject(value, at);
+    authzenNoExtraMembers(obj, at, ['subject', 'action', 'resource', 'context']);
+    if (obj['subject'] === undefined || obj['subject'] === null) {
+        delete obj['subject'];
+    }
+    else {
+        obj['subject'] = validateAuthZENSubject(obj['subject'], `${at}/subject`);
+    }
+    if (obj['action'] === undefined || obj['action'] === null) {
+        delete obj['action'];
+    }
+    else {
+        obj['action'] = validateAuthZENAction(obj['action'], `${at}/action`);
+    }
+    if (obj['resource'] === undefined || obj['resource'] === null) {
+        delete obj['resource'];
+    }
+    else {
+        obj['resource'] = validateAuthZENResource(obj['resource'], `${at}/resource`);
+    }
+    if (obj['context'] === undefined || obj['context'] === null) {
+        delete obj['context'];
+    }
+    else {
+        authzenObject(obj['context'], `${at}/context`);
+    }
+    return obj;
+}
+/**
+ * Validate an unknown value as AuthZENResource, or throw naming the member at fault.
+ * Unknown members are REFUSED rather than dropped: on the response path an
+ * unrecognised member is a server speaking a profile this build does not understand,
+ * and quietly ignoring it would mean acting on a partial reading of an authorization
+ * decision.
+ */
+export function validateAuthZENResource(value, at) {
+    const obj = authzenObject(value, at);
+    authzenNoExtraMembers(obj, at, ['type', 'id', 'properties']);
+    if (obj['type'] === undefined || obj['type'] === null) {
+        authzenFail(`${at}/type`, 'is required');
+    }
+    else {
+        const raw = authzenString(obj['type'], `${at}/type`);
+        if (raw.length < 1) {
+            authzenFail(`${at}/type`, 'must be at least 1 character(s); it is present but too short');
+        }
+    }
+    if (obj['id'] === undefined || obj['id'] === null) {
+        authzenFail(`${at}/id`, 'is required');
+    }
+    else {
+        const raw = authzenString(obj['id'], `${at}/id`);
+        if (raw.length < 1) {
+            authzenFail(`${at}/id`, 'must be at least 1 character(s); it is present but too short');
+        }
+    }
+    if (obj['properties'] === undefined || obj['properties'] === null) {
+        delete obj['properties'];
+    }
+    else {
+        authzenObject(obj['properties'], `${at}/properties`);
+    }
+    return obj;
+}
+/**
+ * Validate an unknown value as AuthZENResponse, or throw naming the member at fault.
+ * Unknown members are REFUSED rather than dropped: on the response path an
+ * unrecognised member is a server speaking a profile this build does not understand,
+ * and quietly ignoring it would mean acting on a partial reading of an authorization
+ * decision.
+ */
+export function validateAuthZENResponse(value, at) {
+    const obj = authzenObject(value, at);
+    authzenNoExtraMembers(obj, at, ['decision', 'context']);
+    if (obj['decision'] === undefined || obj['decision'] === null) {
+        authzenFail(`${at}/decision`, 'is required');
+    }
+    else {
+        authzenBoolean(obj['decision'], `${at}/decision`);
+    }
+    if (obj['context'] === undefined || obj['context'] === null) {
+        delete obj['context'];
+    }
+    else {
+        obj['context'] = validateAuthZENResponseContext(obj['context'], `${at}/context`);
+    }
+    return obj;
+}
+/**
+ * Validate an unknown value as AuthZENResponseContext, or throw naming the member at
+ * fault. Unknown members are REFUSED rather than dropped: on the response path an
+ * unrecognised member is a server speaking a profile this build does not understand,
+ * and quietly ignoring it would mean acting on a partial reading of an authorization
+ * decision.
+ */
+export function validateAuthZENResponseContext(value, at) {
+    const obj = authzenObject(value, at);
+    authzenNoExtraMembers(obj, at, [
+        'profile',
+        'state',
+        'category',
+        'reason',
+        'obligations',
+        'approval',
+        'decision_id',
+        'schema_version',
+    ]);
+    if (obj['profile'] === undefined || obj['profile'] === null) {
+        authzenFail(`${at}/profile`, 'is required');
+    }
+    else {
+        authzenString(obj['profile'], `${at}/profile`);
+    }
+    if (obj['state'] === undefined || obj['state'] === null) {
+        authzenFail(`${at}/state`, 'is required');
+    }
+    else {
+        authzenString(obj['state'], `${at}/state`);
+    }
+    if (obj['category'] === undefined || obj['category'] === null) {
+        authzenFail(`${at}/category`, 'is required');
+    }
+    else {
+        authzenString(obj['category'], `${at}/category`);
+    }
+    if (obj['reason'] === undefined || obj['reason'] === null) {
+        delete obj['reason'];
+    }
+    else {
+        authzenString(obj['reason'], `${at}/reason`);
+    }
+    if (obj['obligations'] === undefined || obj['obligations'] === null) {
+        delete obj['obligations'];
+    }
+    else {
+        const items = authzenArray(obj['obligations'], `${at}/obligations`);
+        obj['obligations'] = items.map((item, index) => validateAuthZENObligation(item, `${`${at}/obligations`}/${index}`));
+    }
+    if (obj['approval'] === undefined || obj['approval'] === null) {
+        delete obj['approval'];
+    }
+    else {
+        obj['approval'] = validateAuthZENApprovalRequirement(obj['approval'], `${at}/approval`);
+    }
+    if (obj['decision_id'] === undefined || obj['decision_id'] === null) {
+        authzenFail(`${at}/decision_id`, 'is required');
+    }
+    else {
+        const raw = authzenString(obj['decision_id'], `${at}/decision_id`);
+        if (raw.length < 1) {
+            authzenFail(`${at}/decision_id`, 'must be at least 1 character(s); it is present but too short');
+        }
+    }
+    if (obj['schema_version'] === undefined || obj['schema_version'] === null) {
+        authzenFail(`${at}/schema_version`, 'is required');
+    }
+    else {
+        const raw = authzenString(obj['schema_version'], `${at}/schema_version`);
+        if (raw.length < 1) {
+            authzenFail(`${at}/schema_version`, 'must be at least 1 character(s); it is present but too short');
+        }
+    }
+    return obj;
+}
+/**
+ * Validate an unknown value as AuthZENSubject, or throw naming the member at fault.
+ * Unknown members are REFUSED rather than dropped: on the response path an
+ * unrecognised member is a server speaking a profile this build does not understand,
+ * and quietly ignoring it would mean acting on a partial reading of an authorization
+ * decision.
+ */
+export function validateAuthZENSubject(value, at) {
+    const obj = authzenObject(value, at);
+    authzenNoExtraMembers(obj, at, ['type', 'id', 'properties']);
+    if (obj['type'] === undefined || obj['type'] === null) {
+        authzenFail(`${at}/type`, 'is required');
+    }
+    else {
+        const raw = authzenString(obj['type'], `${at}/type`);
+        if (raw.length < 1) {
+            authzenFail(`${at}/type`, 'must be at least 1 character(s); it is present but too short');
+        }
+    }
+    if (obj['id'] === undefined || obj['id'] === null) {
+        authzenFail(`${at}/id`, 'is required');
+    }
+    else {
+        const raw = authzenString(obj['id'], `${at}/id`);
+        if (raw.length < 1) {
+            authzenFail(`${at}/id`, 'must be at least 1 character(s); it is present but too short');
+        }
+    }
+    if (obj['properties'] === undefined || obj['properties'] === null) {
+        delete obj['properties'];
+    }
+    else {
+        authzenObject(obj['properties'], `${at}/properties`);
+    }
+    return obj;
+}
+/**
+ * Validate an unknown value as AuthZENIdentifier, or throw naming the member at fault.
+ * Unknown members are REFUSED rather than dropped: on the response path an
+ * unrecognised member is a server speaking a profile this build does not understand,
+ * and quietly ignoring it would mean acting on a partial reading of an authorization
+ * decision.
+ */
+export function validateAuthZENIdentifier(value, at) {
+    const obj = authzenObject(value, at);
+    authzenNoExtraMembers(obj, at, ['kind', 'type', 'qualifier', 'local']);
+    if (obj['kind'] === undefined || obj['kind'] === null) {
+        authzenFail(`${at}/kind`, 'is required');
+    }
+    else {
+        authzenString(obj['kind'], `${at}/kind`);
+    }
+    if (obj['type'] === undefined || obj['type'] === null) {
+        authzenFail(`${at}/type`, 'is required');
+    }
+    else {
+        authzenString(obj['type'], `${at}/type`);
+    }
+    if (obj['qualifier'] === undefined || obj['qualifier'] === null) {
+        delete obj['qualifier'];
+    }
+    else {
+        authzenString(obj['qualifier'], `${at}/qualifier`);
+    }
+    if (obj['local'] === undefined || obj['local'] === null) {
+        authzenFail(`${at}/local`, 'is required');
+    }
+    else {
+        const raw = authzenString(obj['local'], `${at}/local`);
+        if (raw.length < 1) {
+            authzenFail(`${at}/local`, 'must be at least 1 character(s); it is present but too short');
+        }
+    }
+    return obj;
+}
+/**
+ * Validate an unknown value as AuthZENObligation, or throw naming the member at fault.
+ * Unknown members are REFUSED rather than dropped: on the response path an
+ * unrecognised member is a server speaking a profile this build does not understand,
+ * and quietly ignoring it would mean acting on a partial reading of an authorization
+ * decision.
+ */
+export function validateAuthZENObligation(value, at) {
+    const obj = authzenObject(value, at);
+    authzenNoExtraMembers(obj, at, [
+        'type',
+        'target',
+        'params',
+        'mandatory',
+        'source_policy',
+        'schema_version',
+    ]);
+    if (obj['type'] === undefined || obj['type'] === null) {
+        authzenFail(`${at}/type`, 'is required');
+    }
+    else {
+        authzenString(obj['type'], `${at}/type`);
+    }
+    if (obj['target'] === undefined || obj['target'] === null) {
+        delete obj['target'];
+    }
+    else {
+        const raw = authzenString(obj['target'], `${at}/target`);
+        if (raw.length < 1) {
+            authzenFail(`${at}/target`, 'must be at least 1 character(s); it is present but too short');
+        }
+    }
+    if (obj['params'] === undefined || obj['params'] === null) {
+        delete obj['params'];
+    }
+    else {
+        const entries = authzenObject(obj['params'], `${at}/params`);
+        Object.keys(entries).forEach(key => {
+            authzenString(entries[key], `${`${at}/params`}/${key}`);
+        });
+    }
+    if (obj['mandatory'] === undefined || obj['mandatory'] === null) {
+        authzenFail(`${at}/mandatory`, 'is required');
+    }
+    else {
+        authzenBoolean(obj['mandatory'], `${at}/mandatory`);
+    }
+    if (obj['source_policy'] === undefined || obj['source_policy'] === null) {
+        authzenFail(`${at}/source_policy`, 'is required');
+    }
+    else {
+        const raw = authzenString(obj['source_policy'], `${at}/source_policy`);
+        if (raw.length < 1) {
+            authzenFail(`${at}/source_policy`, 'must be at least 1 character(s); it is present but too short');
+        }
+    }
+    if (obj['schema_version'] === undefined || obj['schema_version'] === null) {
+        authzenFail(`${at}/schema_version`, 'is required');
+    }
+    else {
+        authzenInteger(obj['schema_version'], `${at}/schema_version`);
+    }
+    return obj;
+}
+//# sourceMappingURL=authzen.gen.js.map