node-type-registry 0.21.0 → 0.23.0

package/esm/blueprint-types.generated.js

@@ -6,6 +6,12 @@
 //
 // These types match the JSONB shape expected by construct_blueprint().
 // All field names are snake_case to match the SQL convention.
+/**
+ * ===========================================================================
+ * Shared recursive types
+ * ===========================================================================
+ */
+;
 /**
  * ===========================================================================
  * Data node type parameters

package/esm/codegen/generate-types.js

@@ -76,6 +76,15 @@ function partialOf(inner) {
 // ---------------------------------------------------------------------------
 function ensureArrayItems(schema) {
     const out = { ...schema };
+    // Strip $defs — they exist for JSON Schema validators but schema-typescript
+    // doesn't understand them and the TS types are emitted separately.
+    delete out.$defs;
+    // Properties with x-codegen-type get their TS type replaced post-generation,
+    // so collapse them to a simple {type:'object'} to avoid confusing
+    // schema-typescript with $ref or oneOf it can't resolve.
+    if (out['x-codegen-type']) {
+        return { type: 'object', description: out.description, 'x-codegen-type': out['x-codegen-type'] };
+    }
     // Ensure arrays have an items spec (schema-typescript throws without one)
     if (out.type === 'array' && !out.items) {
         out.items = { type: 'string' };
@@ -101,6 +110,93 @@ function ensureArrayItems(schema) {
     return out;
 }
 // ---------------------------------------------------------------------------
+// TriggerCondition — recursive type for compound WHEN clause conditions.
+// Hand-written because JSON Schema / schema-typescript cannot express
+// self-referencing types.
+// ---------------------------------------------------------------------------
+function buildTriggerConditionInterface() {
+    const opType = t.tsUnionType(['=', '!=', '>', '<', '>=', '<=', 'LIKE', 'NOT LIKE', 'IS NULL', 'IS NOT NULL', 'IS DISTINCT FROM']
+        .map((op) => t.tsLiteralType(t.stringLiteral(op))));
+    const rowType = t.tsUnionType([
+        t.tsLiteralType(t.stringLiteral('NEW')),
+        t.tsLiteralType(t.stringLiteral('OLD'))
+    ]);
+    const condRef = t.tsTypeReference(t.identifier('TriggerCondition'));
+    return addJSDoc(exportInterface('TriggerCondition', [
+        addJSDoc(optionalProp('field', t.tsStringKeyword()), 'Column name (validated against the table).'),
+        addJSDoc(optionalProp('op', opType), 'Comparison operator.'),
+        addJSDoc(optionalProp('value', t.tsAnyKeyword()), 'Comparison value. Type is resolved from the column definition.'),
+        addJSDoc(optionalProp('row', rowType), 'Row reference (default: NEW).'),
+        addJSDoc(optionalProp('ref', t.tsTypeLiteral([
+            optionalProp('field', t.tsStringKeyword()),
+            optionalProp('row', rowType)
+        ])), 'Column reference for field-to-field comparison (alternative to value).'),
+        addJSDoc(optionalProp('AND', t.tsArrayType(condRef)), 'Array of conditions combined with AND.'),
+        addJSDoc(optionalProp('OR', t.tsArrayType(condRef)), 'Array of conditions combined with OR.'),
+        addJSDoc(optionalProp('NOT', condRef), 'Negated condition.')
+    ]), 'Recursive condition type for compound trigger WHEN clauses. Leaf conditions specify {field, op, value?, row?, ref?}. Combinators nest via AND, OR, NOT.');
+}
+// ---------------------------------------------------------------------------
+// x-codegen-type post-processing — replaces properties that have an
+// 'x-codegen-type' marker in their JSON Schema with a hand-written TS type
+// reference.  This lets node type definitions delegate complex types
+// (like recursive TriggerCondition) to the codegen instead of trying to
+// express them in JSON Schema.
+// ---------------------------------------------------------------------------
+function applyCodegenTypeOverrides(statements, nodeTypes) {
+    // Build a map of typeName -> { propName -> typeString }
+    const overrides = new Map();
+    for (const nt of nodeTypes) {
+        const props = nt.parameter_schema?.properties;
+        if (!props)
+            continue;
+        for (const [propName, propSchema] of Object.entries(props)) {
+            const schema = propSchema;
+            if (schema['x-codegen-type']) {
+                const typeName = `${nt.name}Params`;
+                if (!overrides.has(typeName))
+                    overrides.set(typeName, new Map());
+                overrides.get(typeName).set(propName, schema['x-codegen-type']);
+            }
+        }
+    }
+    if (overrides.size === 0)
+        return;
+    for (const stmt of statements) {
+        const decl = stmt.declaration;
+        if (!t.isTSInterfaceDeclaration(decl))
+            continue;
+        const ifaceName = decl.id.name;
+        const propOverrides = overrides.get(ifaceName);
+        if (!propOverrides)
+            continue;
+        for (const member of decl.body.body) {
+            if (!t.isTSPropertySignature(member))
+                continue;
+            const key = t.isIdentifier(member.key)
+                ? member.key.name
+                : t.isStringLiteral(member.key)
+                    ? member.key.value
+                    : null;
+            if (!key || !propOverrides.has(key))
+                continue;
+            const typeStr = propOverrides.get(key);
+            // Parse "TypeA | TypeB[]" into a TS union of type references
+            const parts = typeStr.split('|').map((s) => s.trim());
+            const tsTypes = parts.map((part) => {
+                const isArray = part.endsWith('[]');
+                const name = isArray ? part.slice(0, -2) : part;
+                const ref = t.tsTypeReference(t.identifier(name));
+                return isArray ? t.tsArrayType(ref) : ref;
+            });
+            const annotation = tsTypes.length === 1
+                ? tsTypes[0]
+                : t.tsUnionType(tsTypes);
+            member.typeAnnotation = t.tsTypeAnnotation(annotation);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
 // Generate per-node-type parameter interfaces via schema-typescript
 // ---------------------------------------------------------------------------
 function generateParamsInterfaces(nodeTypes) {
@@ -127,6 +223,9 @@ function generateParamsInterfaces(nodeTypes) {
             results.push(addJSDoc(exportInterface(typeName, []), nt.description));
         }
     }
+    // Apply x-codegen-type overrides to replace schema-generated types with
+    // hand-written recursive types (e.g. TriggerCondition)
+    applyCodegenTypeOverrides(results, nodeTypes);
     return results;
 }
 // ---------------------------------------------------------------------------
@@ -388,9 +487,8 @@ function buildBlueprintStorageConfig() {
         addJSDoc(optionalProp('allowed_origins', t.tsArrayType(t.tsStringKeyword())), 'CORS allowed origins for the storage module.'),
         addJSDoc(optionalProp('provisions', t.tsTypeLiteral([
             optionalProp('files', t.tsTypeReference(t.identifier('BlueprintEntityTableProvision'))),
-            optionalProp('buckets', t.tsTypeReference(t.identifier('BlueprintEntityTableProvision'))),
-            optionalProp('upload_requests', t.tsTypeReference(t.identifier('BlueprintEntityTableProvision')))
-        ])), 'Per-table overrides for storage tables. Each key targets a specific storage table (files, buckets, upload_requests) and uses the same shape as table_provision: { nodes, fields, grants, use_rls, policies }. Fanned out to secure_table_provision targeting the corresponding table. When a key includes policies[], those REPLACE the default storage policies for that table; tables without a key still get defaults.')
+            optionalProp('buckets', t.tsTypeReference(t.identifier('BlueprintEntityTableProvision')))
+        ])), 'Per-table overrides for storage tables. Each key targets a specific storage table (files, buckets) and uses the same shape as table_provision: { nodes, fields, grants, use_rls, policies }. Fanned out to secure_table_provision targeting the corresponding table. When a key includes policies[], those REPLACE the default storage policies for that table; tables without a key still get defaults.')
     ]), 'Storage configuration for an entity type. Seeds initial buckets, overrides module-level settings (expiry times, file size limits, CORS), and provides per-table provisioning overrides via provisions.');
 }
 function buildBlueprintEntityTableProvision() {
@@ -416,7 +514,7 @@ function buildBlueprintEntityType() {
         addJSDoc(optionalProp('has_limits', t.tsBooleanKeyword()), 'Whether to provision a limits module for this entity type. Defaults to false.'),
         addJSDoc(optionalProp('has_profiles', t.tsBooleanKeyword()), 'Whether to provision a profiles module for this entity type. Defaults to false.'),
         addJSDoc(optionalProp('has_levels', t.tsBooleanKeyword()), 'Whether to provision a levels module for this entity type. Defaults to false.'),
-        addJSDoc(optionalProp('has_storage', t.tsBooleanKeyword()), 'Whether to provision a storage module (buckets, files, upload_requests tables) for this entity type. Defaults to false.'),
+        addJSDoc(optionalProp('has_storage', t.tsBooleanKeyword()), 'Whether to provision a storage module (buckets, files tables) for this entity type. Defaults to false.'),
         addJSDoc(optionalProp('has_invites', t.tsBooleanKeyword()), 'Whether to provision entity-scoped invite tables ({prefix}_invites, {prefix}_claimed_invites) and a submit_{prefix}_invite_code() function. Defaults to false.'),
         addJSDoc(optionalProp('skip_entity_policies', t.tsBooleanKeyword()), 'Escape hatch: when true AND table_provision is NULL, zero policies are provisioned on the entity table. Defaults to false.'),
         addJSDoc(optionalProp('table_provision', t.tsTypeReference(t.identifier('BlueprintEntityTableProvision'))), 'Override for the entity table. Shape mirrors BlueprintTable / secure_table_provision vocabulary. When supplied, its policies[] replaces the five default entity-table policies; is_visible becomes a no-op. When NULL (default), the five default policies are applied (gated by is_visible).'),
@@ -479,6 +577,9 @@ function buildProgram(meta) {
     const dataNodes = allNodeTypes.filter((nt) => nt.category !== 'relation' && nt.category !== 'view');
     const relationNodes = allNodeTypes.filter((nt) => nt.category === 'relation');
     const authzNodes = allNodeTypes.filter((nt) => nt.category === 'authz');
+    // -- Shared recursive types (emitted before parameter interfaces) --
+    statements.push(sectionComment('Shared recursive types'));
+    statements.push(buildTriggerConditionInterface());
     // -- Parameter interfaces grouped by category --
     const categoryOrder = ['data', 'search', 'authz', 'relation', 'view'];
     for (const cat of categoryOrder) {

package/esm/data/data-feature-flag.d.ts

@@ -0,0 +1,2 @@
+import type { NodeTypeDefinition } from '../types';
+export declare const DataFeatureFlag: NodeTypeDefinition;

package/esm/data/data-feature-flag.js

@@ -0,0 +1,30 @@
+export const DataFeatureFlag = {
+    name: 'DataFeatureFlag',
+    slug: 'data_feature_flag',
+    category: 'data',
+    display_name: 'Feature Flag',
+    description: 'Gates a table behind a feature flag backed by the cap tables. Attaches a BEFORE INSERT trigger that checks whether the named feature cap value is > 0. Features are modeled as caps with max=0 (disabled) or max=1 (enabled) in limit_caps / limit_caps_defaults tables. Resolution: COALESCE(per-entity cap, scope default, 0).',
+    parameter_schema: {
+        type: 'object',
+        properties: {
+            feature_name: {
+                type: 'string',
+                description: 'Cap name representing this feature (must match a limit_caps_defaults entry with max=0 or max=1)',
+            },
+            scope: {
+                type: 'string',
+                enum: ['app', 'org'],
+                description: 'Feature scope: "app" (membership_type=1, app-level caps) or "org" (membership_type=2, per-entity caps)',
+                default: 'app',
+            },
+            entity_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column on the target table that holds the entity id for per-entity cap lookups (only used for org scope)',
+                default: 'entity_id',
+            },
+        },
+        required: ['feature_name'],
+    },
+    tags: ['limits', 'triggers', 'feature-flags', 'billing', 'caps'],
+};

package/esm/data/data-image-embedding.d.ts

@@ -0,0 +1,2 @@
+import type { NodeTypeDefinition } from '../types';
+export declare const DataImageEmbedding: NodeTypeDefinition;

package/esm/data/data-image-embedding.js

@@ -0,0 +1,77 @@
+export const DataImageEmbedding = {
+    name: 'DataImageEmbedding',
+    slug: 'data_image_embedding',
+    category: 'data',
+    display_name: 'Image Embedding',
+    description: 'Composition wrapper that creates a vector embedding field with HNSW/IVFFlat index (via SearchVector) and a job trigger with compound conditions (via DataJobTrigger) that fires on INSERT for image files matching mime_type patterns. Designed for storage file tables.',
+    parameter_schema: {
+        type: 'object',
+        properties: {
+            field_name: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Name of the vector embedding column',
+                default: 'embedding'
+            },
+            dimensions: {
+                type: 'integer',
+                description: 'Vector dimensions',
+                default: 512
+            },
+            index_method: {
+                type: 'string',
+                enum: [
+                    'hnsw',
+                    'ivfflat'
+                ],
+                description: 'Index type for similarity search',
+                default: 'hnsw'
+            },
+            metric: {
+                type: 'string',
+                enum: [
+                    'cosine',
+                    'l2',
+                    'ip'
+                ],
+                description: 'Distance metric',
+                default: 'cosine'
+            },
+            task_identifier: {
+                type: 'string',
+                description: 'Job task identifier for the embedding worker',
+                default: 'process_image_embedding'
+            },
+            mime_patterns: {
+                type: 'array',
+                items: {
+                    type: 'string'
+                },
+                description: 'MIME type LIKE patterns to match (e.g., image/%, video/%). Multiple patterns are OR\'d together.',
+                default: ['image/%']
+            },
+            payload_custom: {
+                type: 'object',
+                additionalProperties: {
+                    type: 'string',
+                    format: 'column-ref'
+                },
+                description: 'Custom payload key-to-column mapping for the job trigger',
+                default: {
+                    file_id: 'id',
+                    key: 'key',
+                    mime_type: 'mime_type',
+                    bucket_id: 'bucket_id'
+                }
+            }
+        }
+    },
+    tags: [
+        'embedding',
+        'image',
+        'vector',
+        'ai',
+        'composition',
+        'jobs'
+    ]
+};

package/esm/data/data-job-trigger.js

@@ -1,3 +1,28 @@
+const triggerConditionSchema = {
+    type: 'object',
+    description: 'A leaf condition ({field, op, value?, row?, ref?}) or a combinator ({AND, OR, NOT}).',
+    properties: {
+        field: { type: 'string', format: 'column-ref', description: 'Column name (validated against the table).' },
+        op: {
+            type: 'string',
+            enum: ['=', '!=', '>', '<', '>=', '<=', 'LIKE', 'NOT LIKE', 'IS NULL', 'IS NOT NULL', 'IS DISTINCT FROM'],
+            description: 'Comparison operator.'
+        },
+        value: { description: 'Comparison value. Type is resolved from the column definition. Omit for IS NULL, IS NOT NULL, IS DISTINCT FROM.' },
+        row: { type: 'string', enum: ['NEW', 'OLD'], default: 'NEW', description: 'Row reference (default: NEW).' },
+        ref: {
+            type: 'object',
+            description: 'Column reference for field-to-field comparison (alternative to value).',
+            properties: {
+                field: { type: 'string', format: 'column-ref' },
+                row: { type: 'string', enum: ['NEW', 'OLD'], default: 'NEW' }
+            }
+        },
+        AND: { type: 'array', description: 'Array of conditions combined with AND.', items: { $ref: '#/$defs/triggerCondition' } },
+        OR: { type: 'array', description: 'Array of conditions combined with OR.', items: { $ref: '#/$defs/triggerCondition' } },
+        NOT: { $ref: '#/$defs/triggerCondition', description: 'Negated condition.' }
+    }
+};
 export const DataJobTrigger = {
     name: 'DataJobTrigger',
     slug: 'data_job_trigger',
@@ -6,6 +31,9 @@ export const DataJobTrigger = {
     description: 'Dynamically creates PostgreSQL triggers that enqueue jobs via app_jobs.add_job() when table rows are inserted, updated, or deleted. Supports configurable payload strategies (full row, row ID, selected fields, or custom mapping), conditional firing via WHEN clauses, watched field changes, and extended job options (queue, priority, delay, max attempts).',
     parameter_schema: {
         type: 'object',
+        $defs: {
+            triggerCondition: triggerConditionSchema
+        },
         properties: {
             task_identifier: {
                 type: 'string',
@@ -33,7 +61,8 @@ export const DataJobTrigger = {
             payload_custom: {
                 type: 'object',
                 additionalProperties: {
-                    type: 'string'
+                    type: 'string',
+                    format: 'column-ref'
                 },
                 description: 'Key-to-column mapping for custom payload (e.g., {"invoice_id": "id", "total": "amount"})'
             },
@@ -72,6 +101,14 @@ export const DataJobTrigger = {
                 type: 'string',
                 description: 'Value to compare against condition_field in WHEN clause'
             },
+            conditions: {
+                description: 'Compound conditions for the trigger WHEN clause. Accepts a single leaf condition, an array of conditions (implicitly AND), or a nested combinator tree ({AND: [...], OR: [...], NOT: {...}}). Each leaf is {field, op, value?, row?, ref?}. Column types are resolved automatically from the table schema. Cannot be combined with condition_field or watch_fields.',
+                'x-codegen-type': 'TriggerCondition | TriggerCondition[]',
+                oneOf: [
+                    { $ref: '#/$defs/triggerCondition' },
+                    { type: 'array', items: { $ref: '#/$defs/triggerCondition' } }
+                ]
+            },
             watch_fields: {
                 type: 'array',
                 items: {

package/esm/data/data-limit-counter.d.ts

@@ -0,0 +1,2 @@
+import type { NodeTypeDefinition } from '../types';
+export declare const DataLimitCounter: NodeTypeDefinition;

package/esm/data/data-limit-counter.js

@@ -0,0 +1,39 @@
+export const DataLimitCounter = {
+    name: 'DataLimitCounter',
+    slug: 'data_limit_counter',
+    category: 'data',
+    display_name: 'Limit Counter',
+    description: 'Declaratively attaches limit-tracking triggers to a table. On INSERT the named limit is incremented; on DELETE it is decremented. Requires a provisioned limits_module for the target scope.',
+    parameter_schema: {
+        type: 'object',
+        properties: {
+            limit_name: {
+                type: 'string',
+                description: 'Name of the limit to track (must match a default_limits entry, e.g. "projects", "members")',
+            },
+            scope: {
+                type: 'string',
+                enum: ['app', 'org'],
+                description: 'Limit scope: "app" (membership_type=1, user-level) or "org" (membership_type=2, entity-level)',
+                default: 'app',
+            },
+            actor_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column on the target table that holds the actor or entity id used for limit lookup',
+                default: 'owner_id',
+            },
+            events: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                    enum: ['INSERT', 'DELETE', 'UPDATE'],
+                },
+                description: 'Which DML events to attach triggers for',
+                default: ['INSERT', 'DELETE'],
+            },
+        },
+        required: ['limit_name'],
+    },
+    tags: ['limits', 'triggers', 'billing'],
+};

package/esm/data/data-ownership-in-entity.js

@@ -7,6 +7,18 @@ export const DataOwnershipInEntity = {
     parameter_schema: {
         type: 'object',
         properties: {
+            owner_field_name: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column name for the owner reference',
+                default: 'owner_id'
+            },
+            entity_field_name: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column name for the entity reference',
+                default: 'entity_id'
+            },
             include_id: {
                 type: 'boolean',
                 description: 'If true, also adds a UUID primary key column with auto-generation',

package/esm/data/data-peoplestamps.js

@@ -7,6 +7,18 @@ export const DataPeoplestamps = {
     parameter_schema: {
         type: 'object',
         properties: {
+            created_by_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column name for the creating user reference',
+                default: 'created_by'
+            },
+            updated_by_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column name for the last-updating user reference',
+                default: 'updated_by'
+            },
             include_id: {
                 type: 'boolean',
                 description: 'If true, also adds a UUID primary key column with auto-generation',

package/esm/data/data-publishable.js

@@ -7,6 +7,18 @@ export const DataPublishable = {
     parameter_schema: {
         type: 'object',
         properties: {
+            is_published_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column name for the published boolean flag',
+                default: 'is_published'
+            },
+            published_at_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column name for the publish timestamp',
+                default: 'published_at'
+            },
             include_id: {
                 type: 'boolean',
                 description: 'If true, also adds a UUID primary key column with auto-generation',

package/esm/data/data-soft-delete.js

@@ -7,6 +7,18 @@ export const DataSoftDelete = {
     parameter_schema: {
         type: 'object',
         properties: {
+            deleted_at_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column name for the soft-delete timestamp',
+                default: 'deleted_at'
+            },
+            is_deleted_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column name for the soft-delete boolean flag',
+                default: 'is_deleted'
+            },
             include_id: {
                 type: 'boolean',
                 description: 'If true, also adds a UUID primary key column with auto-generation',

package/esm/data/data-timestamps.js

@@ -7,6 +7,18 @@ export const DataTimestamps = {
     parameter_schema: {
         type: 'object',
         properties: {
+            created_at_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column name for the creation timestamp',
+                default: 'created_at'
+            },
+            updated_at_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column name for the last-updated timestamp',
+                default: 'updated_at'
+            },
             include_id: {
                 type: 'boolean',
                 description: 'If true, also adds a UUID primary key column with auto-generation',

package/esm/data/index.d.ts

@@ -1,12 +1,15 @@
 export { DataCompositeField } from './data-composite-field';
 export { DataDirectOwner } from './data-direct-owner';
 export { DataEntityMembership } from './data-entity-membership';
+export { DataFeatureFlag } from './data-feature-flag';
 export { DataForceCurrentUser } from './data-force-current-user';
 export { DataId } from './data-id';
+export { DataImageEmbedding } from './data-image-embedding';
 export { DataImmutableFields } from './data-immutable-fields';
 export { DataInflection } from './data-inflection';
 export { DataInheritFromParent } from './data-inherit-from-parent';
 export { DataJobTrigger } from './data-job-trigger';
+export { DataLimitCounter } from './data-limit-counter';
 export { DataJsonb } from './data-jsonb';
 export { DataOwnedFields } from './data-owned-fields';
 export { DataOwnershipInEntity } from './data-ownership-in-entity';

package/esm/data/index.js

@@ -1,12 +1,15 @@
 export { DataCompositeField } from './data-composite-field';
 export { DataDirectOwner } from './data-direct-owner';
 export { DataEntityMembership } from './data-entity-membership';
+export { DataFeatureFlag } from './data-feature-flag';
 export { DataForceCurrentUser } from './data-force-current-user';
 export { DataId } from './data-id';
+export { DataImageEmbedding } from './data-image-embedding';
 export { DataImmutableFields } from './data-immutable-fields';
 export { DataInflection } from './data-inflection';
 export { DataInheritFromParent } from './data-inherit-from-parent';
 export { DataJobTrigger } from './data-job-trigger';
+export { DataLimitCounter } from './data-limit-counter';
 export { DataJsonb } from './data-jsonb';
 export { DataOwnedFields } from './data-owned-fields';
 export { DataOwnershipInEntity } from './data-ownership-in-entity';

package/esm/view/view-aggregated.js

@@ -42,6 +42,7 @@ export const ViewAggregated = {
                         },
                         alias: {
                             type: 'string',
+                            format: 'column-ref',
                             description: 'Output column name'
                         }
                     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-type-registry",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "description": "Node type definitions for the Constructive blueprint system. Single source of truth for all Authz*, Data*, Relation*, and View* node types.",
   "author": "Constructive <developers@constructive.io>",
   "main": "index.js",
@@ -47,5 +47,5 @@
     "registry",
     "graphile"
   ],
-  "gitHead": "425a7111ec17cbe975a12c8528e7cef151fc03df"
+  "gitHead": "fb12131bc72ca66e2eb554e15c49e35dc5b362ac"
 }

package/view/view-aggregated.js

@@ -45,6 +45,7 @@ exports.ViewAggregated = {
                         },
                         alias: {
                             type: 'string',
+                            format: 'column-ref',
                             description: 'Output column name'
                         }
                     },

package/authz/authz-membership-check.d.ts

@@ -1,2 +0,0 @@
-import type { NodeTypeDefinition } from '../types';
-export declare const AuthzMembership: NodeTypeDefinition;

package/esm/authz/authz-membership-check.d.ts

@@ -1,2 +0,0 @@
-import type { NodeTypeDefinition } from '../types';
-export declare const AuthzMembership: NodeTypeDefinition;