node-type-registry 0.36.0 → 0.38.0

package/esm/{data/process-image-versions.js → process/image-versions.js}

@@ -1,3 +1,4 @@
+import { conditionDefs, triggerConditionsProperty } from '../conditions';
 /**
  * Image version processing node.
  *
@@ -23,6 +24,7 @@ export const ProcessImageVersions = {
         'file records linked to the source image.',
     parameter_schema: {
         type: 'object',
+        $defs: conditionDefs,
         required: ['versions'],
         properties: {
             // ── Version definitions ───────────────────────────────────────
@@ -98,15 +100,7 @@ export const ProcessImageVersions = {
                     bucket_id: 'bucket_id'
                 }
             },
-            trigger_conditions: {
-                description: 'Additional compound conditions beyond MIME filtering. ' +
-                    'Merged with the auto-generated MIME conditions via AND.',
-                'x-codegen-type': 'TriggerCondition | TriggerCondition[]',
-                oneOf: [
-                    { $ref: '#/$defs/triggerCondition' },
-                    { type: 'array', items: { $ref: '#/$defs/triggerCondition' } }
-                ]
-            },
+            trigger_conditions: triggerConditionsProperty,
             // ── Job options ───────────────────────────────────────────────
             queue_name: {
                 type: 'string',

package/esm/process/index.d.ts

@@ -0,0 +1,5 @@
+export { ProcessChunks } from './chunks';
+export { ProcessExtraction } from './extraction';
+export { ProcessFileEmbedding } from './file-embedding';
+export { ProcessImageEmbedding } from './image-embedding';
+export { ProcessImageVersions } from './image-versions';

package/esm/process/index.js

@@ -0,0 +1,5 @@
+export { ProcessChunks } from './chunks';
+export { ProcessExtraction } from './extraction';
+export { ProcessFileEmbedding } from './file-embedding';
+export { ProcessImageEmbedding } from './image-embedding';
+export { ProcessImageVersions } from './image-versions';

package/event/index.d.ts

@@ -0,0 +1,2 @@
+export { EventReferral } from './referral';
+export { EventTracker } from './tracker';

package/event/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventTracker = exports.EventReferral = void 0;
+var referral_1 = require("./referral");
+Object.defineProperty(exports, "EventReferral", { enumerable: true, get: function () { return referral_1.EventReferral; } });
+var tracker_1 = require("./tracker");
+Object.defineProperty(exports, "EventTracker", { enumerable: true, get: function () { return tracker_1.EventTracker; } });

package/event/referral.d.ts

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

package/event/referral.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventReferral = void 0;
+const conditions_1 = require("../conditions");
+exports.EventReferral = {
+    name: 'EventReferral',
+    slug: 'event_referral',
+    category: 'event',
+    display_name: 'Event Referral',
+    description: 'Creates triggers that record events for the referrer (inviter) when their ' +
+        'invitees perform actions on a watched table. Resolves the referrer automatically ' +
+        'via the invites module\'s claimed_invites table using the membership_type context. ' +
+        'Supports the same compound condition system as EventTracker. Use with achievements ' +
+        'to unlock levels and grant credits based on invitee activity.',
+    parameter_schema: {
+        type: 'object',
+        $defs: conditions_1.conditionDefs,
+        properties: {
+            event_name: {
+                type: 'string',
+                description: 'Event type name to record for the referrer (e.g., "invitee_uploaded_avatar", "invitee_completed_onboarding")'
+            },
+            events: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                    enum: [
+                        'INSERT',
+                        'UPDATE',
+                        'DELETE'
+                    ]
+                },
+                description: 'DML events that trigger recording',
+                default: ['INSERT']
+            },
+            actor_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column containing the invitee (actor) ID on the source table — used to look up the referrer via claimed_invites.receiver_id',
+                default: 'owner_id'
+            },
+            entity_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column containing the entity ID (org/group) for entity-scoped referral events. Omit for user-only events.'
+            },
+            auto_register_type: {
+                type: 'boolean',
+                description: 'Automatically register the event_name in event_types during provisioning',
+                default: true
+            },
+            ...conditions_1.conditionProperties
+        },
+        required: [
+            'event_name'
+        ]
+    },
+    tags: [
+        'events',
+        'referral',
+        'invites',
+        'analytics',
+        'tracking'
+    ]
+};

package/event/tracker.d.ts

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

package/event/tracker.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventTracker = void 0;
+const conditions_1 = require("../conditions");
+exports.EventTracker = {
+    name: 'EventTracker',
+    slug: 'event_tracker',
+    category: 'event',
+    display_name: 'Event Tracker',
+    description: 'Creates triggers that record events via the events module when table rows change. ' +
+        'Supports the same compound condition system as JobTrigger (condition_field, watch_fields, ' +
+        'or full AND/OR/NOT conditions). Events are recorded to app_events and aggregated ' +
+        'automatically. Use with achievements (blueprint-level) to unlock levels and grant ' +
+        'credits based on event accumulation.',
+    parameter_schema: {
+        type: 'object',
+        $defs: conditions_1.conditionDefs,
+        properties: {
+            event_name: {
+                type: 'string',
+                description: 'Event type name to record (e.g., "avatar_uploaded", "order_completed")'
+            },
+            events: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                    enum: [
+                        'INSERT',
+                        'UPDATE',
+                        'DELETE'
+                    ]
+                },
+                description: 'DML events that trigger recording',
+                default: ['INSERT']
+            },
+            count: {
+                type: 'integer',
+                description: 'Number of events to record per trigger fire',
+                default: 1
+            },
+            toggle: {
+                type: 'boolean',
+                description: 'Toggle mode: records event when condition is met, removes when condition is unmet',
+                default: false
+            },
+            actor_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column containing the actor (user) ID to attribute the event to',
+                default: 'owner_id'
+            },
+            entity_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column containing the entity ID (org/group) for entity-scoped events. Omit for user-only events.'
+            },
+            auto_register_type: {
+                type: 'boolean',
+                description: 'Automatically register the event_name in event_types during provisioning',
+                default: true
+            },
+            ...conditions_1.conditionProperties
+        },
+        required: [
+            'event_name'
+        ]
+    },
+    tags: [
+        'events',
+        'triggers',
+        'analytics',
+        'tracking'
+    ]
+};

package/index.d.ts

@@ -1,7 +1,12 @@
 export * from './authz';
 export * from './blueprint-types.generated';
+export * from './conditions';
 export * from './data';
+export * from './event';
+export * from './job';
+export * from './limit';
 export * from './module-presets';
+export * from './process';
 export * from './relation';
 export type { JSONSchema, NodeTypeDefinition } from './types';
 export * from './view';

package/index.js

@@ -39,17 +39,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.allNodeTypes = void 0;
 __exportStar(require("./authz"), exports);
 __exportStar(require("./blueprint-types.generated"), exports);
+__exportStar(require("./conditions"), exports);
 __exportStar(require("./data"), exports);
+__exportStar(require("./event"), exports);
+__exportStar(require("./job"), exports);
+__exportStar(require("./limit"), exports);
 __exportStar(require("./module-presets"), exports);
+__exportStar(require("./process"), exports);
 __exportStar(require("./relation"), exports);
 __exportStar(require("./view"), exports);
 const authz = __importStar(require("./authz"));
 const data = __importStar(require("./data"));
+const event = __importStar(require("./event"));
+const job = __importStar(require("./job"));
+const limit = __importStar(require("./limit"));
+const process = __importStar(require("./process"));
 const relation = __importStar(require("./relation"));
 const view = __importStar(require("./view"));
 exports.allNodeTypes = [
     ...Object.values(authz),
     ...Object.values(data),
+    ...Object.values(event),
+    ...Object.values(job),
+    ...Object.values(limit),
+    ...Object.values(process),
     ...Object.values(relation),
     ...Object.values(view)
 ];

package/job/index.d.ts

@@ -0,0 +1 @@
+export { JobTrigger } from './trigger';

package/job/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobTrigger = void 0;
+var trigger_1 = require("./trigger");
+Object.defineProperty(exports, "JobTrigger", { enumerable: true, get: function () { return trigger_1.JobTrigger; } });

package/{data/data-job-trigger.js → job/trigger.js}

@@ -1,31 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JobTrigger = void 0;
-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.' }
-    }
-};
+const conditions_1 = require("../conditions");
 exports.JobTrigger = {
     name: 'JobTrigger',
     slug: 'data_job_trigger',
@@ -34,9 +10,7 @@ exports.JobTrigger = {
     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
-        },
+        $defs: conditions_1.conditionDefs,
         properties: {
             task_identifier: {
                 type: 'string',
@@ -95,31 +69,7 @@ exports.JobTrigger = {
                 description: 'Include table/schema metadata in payload',
                 default: false
             },
-            condition_field: {
-                type: 'string',
-                format: 'column-ref',
-                description: 'Column name for conditional WHEN clause (fires only when field equals condition_value)'
-            },
-            condition_value: {
-                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: {
-                    type: 'string',
-                    format: 'column-ref'
-                },
-                description: 'For UPDATE triggers, only fire when these fields change (uses DISTINCT FROM)'
-            },
+            ...conditions_1.conditionProperties,
             job_key: {
                 type: 'string',
                 description: 'Static job key for upsert semantics (prevents duplicate jobs)'

package/limit/enforce-aggregate.d.ts

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

package/{data/data-aggregate-limit-counter.js → limit/enforce-aggregate.js}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LimitAggregate = void 0;
-exports.LimitAggregate = {
-    name: 'LimitAggregate',
-    slug: 'data_aggregate_limit_counter',
-    category: 'limit',
-    display_name: 'Aggregate Limit Counter',
+exports.LimitEnforceAggregate = void 0;
+exports.LimitEnforceAggregate = {
+    name: 'LimitEnforceAggregate',
+    slug: 'limit_enforce_aggregate',
+    category: 'limit_enforce',
+    display_name: 'Enforce Aggregate Counter',
     description: 'Declaratively attaches aggregate limit-tracking triggers to a table. On INSERT the named limit is incremented per entity; on DELETE it is decremented. Uses org_limit_aggregates_inc/dec for per-entity (org-level) aggregate limits rather than per-user limits. Requires a provisioned limits_module for the target database.',
     parameter_schema: {
         type: 'object',
@@ -32,5 +32,5 @@ exports.LimitAggregate = {
         },
         required: ['limit_name'],
     },
-    tags: ['limits', 'triggers', 'aggregates', 'billing'],
+    tags: ['limits', 'triggers', 'aggregates', 'enforce'],
 };

package/limit/enforce-counter.d.ts

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

package/{data/data-limit-counter.js → limit/enforce-counter.js}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LimitCounter = void 0;
-exports.LimitCounter = {
-    name: 'LimitCounter',
-    slug: 'data_limit_counter',
-    category: 'limit',
-    display_name: 'Limit Counter',
+exports.LimitEnforceCounter = void 0;
+exports.LimitEnforceCounter = {
+    name: 'LimitEnforceCounter',
+    slug: 'limit_enforce_counter',
+    category: 'limit_enforce',
+    display_name: 'Enforce 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',
@@ -38,5 +38,5 @@ exports.LimitCounter = {
         },
         required: ['limit_name'],
     },
-    tags: ['limits', 'triggers', 'billing'],
+    tags: ['limits', 'triggers', 'enforce'],
 };

package/limit/enforce-feature.d.ts

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

package/{data/data-feature-flag.js → limit/enforce-feature.js}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LimitFeatureFlag = void 0;
-exports.LimitFeatureFlag = {
-    name: 'LimitFeatureFlag',
-    slug: 'data_feature_flag',
-    category: 'limit',
-    display_name: 'Feature Flag',
+exports.LimitEnforceFeature = void 0;
+exports.LimitEnforceFeature = {
+    name: 'LimitEnforceFeature',
+    slug: 'limit_enforce_feature',
+    category: 'limit_enforce',
+    display_name: 'Enforce 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',
@@ -29,5 +29,5 @@ exports.LimitFeatureFlag = {
         },
         required: ['feature_name'],
     },
-    tags: ['limits', 'triggers', 'feature-flags', 'billing', 'caps'],
+    tags: ['limits', 'triggers', 'feature-flags', 'enforce', 'caps'],
 };

package/limit/enforce-rate.d.ts

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

package/limit/enforce-rate.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LimitEnforceRate = void 0;
+exports.LimitEnforceRate = {
+    name: 'LimitEnforceRate',
+    slug: 'limit_enforce_rate',
+    category: 'limit_enforce',
+    display_name: 'Enforce Rate Limit',
+    description: 'Attaches a BEFORE trigger that calls check_rate_limit() to enforce sliding-window rate limits before allowing mutations. The function checks all three scopes (entity, actor-in-entity, actor) in a single call; which scopes are actually enforced is controlled by what rows exist in rate_window_limits (plan-based config). Requires a provisioned meter_rate_limits_module and billing_module for the target database.',
+    parameter_schema: {
+        type: 'object',
+        properties: {
+            meter_slug: {
+                type: 'string',
+                description: 'Slug of the billing meter to check rate limits against (must match a meters table entry, e.g. "messaging", "inference")',
+            },
+            entity_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column on the target table that holds the entity id (org) for rate limiting',
+                default: 'entity_id',
+            },
+            actor_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column on the target table that holds the actor id (user) for rate limiting',
+                default: 'owner_id',
+            },
+            events: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                    enum: ['INSERT', 'UPDATE'],
+                },
+                description: 'Which DML events to enforce rate limits on (DELETE is excluded since it reduces load)',
+                default: ['INSERT'],
+            },
+        },
+        required: ['meter_slug'],
+    },
+    tags: ['rate-limits', 'triggers', 'enforce', 'metering', 'abuse-protection'],
+};

package/limit/index.d.ts

@@ -0,0 +1,8 @@
+export { LimitEnforceAggregate } from './enforce-aggregate';
+export { LimitEnforceCounter } from './enforce-counter';
+export { LimitEnforceFeature } from './enforce-feature';
+export { LimitEnforceRate } from './enforce-rate';
+export { LimitTrackUsage } from './track-usage';
+export { LimitWarningAggregate } from './warning-aggregate';
+export { LimitWarningCounter } from './warning-counter';
+export { LimitWarningRate } from './warning-rate';

package/limit/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LimitWarningRate = exports.LimitWarningCounter = exports.LimitWarningAggregate = exports.LimitTrackUsage = exports.LimitEnforceRate = exports.LimitEnforceFeature = exports.LimitEnforceCounter = exports.LimitEnforceAggregate = void 0;
+var enforce_aggregate_1 = require("./enforce-aggregate");
+Object.defineProperty(exports, "LimitEnforceAggregate", { enumerable: true, get: function () { return enforce_aggregate_1.LimitEnforceAggregate; } });
+var enforce_counter_1 = require("./enforce-counter");
+Object.defineProperty(exports, "LimitEnforceCounter", { enumerable: true, get: function () { return enforce_counter_1.LimitEnforceCounter; } });
+var enforce_feature_1 = require("./enforce-feature");
+Object.defineProperty(exports, "LimitEnforceFeature", { enumerable: true, get: function () { return enforce_feature_1.LimitEnforceFeature; } });
+var enforce_rate_1 = require("./enforce-rate");
+Object.defineProperty(exports, "LimitEnforceRate", { enumerable: true, get: function () { return enforce_rate_1.LimitEnforceRate; } });
+var track_usage_1 = require("./track-usage");
+Object.defineProperty(exports, "LimitTrackUsage", { enumerable: true, get: function () { return track_usage_1.LimitTrackUsage; } });
+var warning_aggregate_1 = require("./warning-aggregate");
+Object.defineProperty(exports, "LimitWarningAggregate", { enumerable: true, get: function () { return warning_aggregate_1.LimitWarningAggregate; } });
+var warning_counter_1 = require("./warning-counter");
+Object.defineProperty(exports, "LimitWarningCounter", { enumerable: true, get: function () { return warning_counter_1.LimitWarningCounter; } });
+var warning_rate_1 = require("./warning-rate");
+Object.defineProperty(exports, "LimitWarningRate", { enumerable: true, get: function () { return warning_rate_1.LimitWarningRate; } });

package/limit/track-usage.d.ts

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

package/{data/data-billing-meter.js → limit/track-usage.js}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BillingMeter = void 0;
-exports.BillingMeter = {
-    name: 'BillingMeter',
-    slug: 'data_billing_meter',
-    category: 'billing',
-    display_name: 'Billing Meter',
+exports.LimitTrackUsage = void 0;
+exports.LimitTrackUsage = {
+    name: 'LimitTrackUsage',
+    slug: 'limit_track_usage',
+    category: 'limit_track',
+    display_name: 'Track Usage',
     description: 'Declaratively attaches billing usage-recording triggers to a table. On INSERT the named meter is incremented via record_usage; on DELETE it is decremented (reversal). On UPDATE, if the entity_field changes, the old entity is decremented and the new entity is incremented. Requires a provisioned billing_module for the target database.',
     parameter_schema: {
         type: 'object',
@@ -37,5 +37,5 @@ exports.BillingMeter = {
         },
         required: ['meter_slug'],
     },
-    tags: ['billing', 'triggers', 'metering', 'usage'],
+    tags: ['billing', 'triggers', 'metering', 'usage', 'track'],
 };

package/limit/warning-aggregate.d.ts

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

package/limit/warning-aggregate.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LimitWarningAggregate = void 0;
+exports.LimitWarningAggregate = {
+    name: 'LimitWarningAggregate',
+    slug: 'limit_warning_aggregate',
+    category: 'limit_warning',
+    display_name: 'Warning Aggregate',
+    description: 'Attaches an AFTER INSERT trigger that checks if the entity\'s aggregate usage has crossed any warning threshold configured in the limit_warnings table. If a threshold is reached for the first time, enqueues a background job (e.g. email notification). Uses limit_warning_state for one-time dedup per warning/actor/entity triple. Requires a provisioned limits_module with limit_warnings and aggregate limits enabled.',
+    parameter_schema: {
+        type: 'object',
+        properties: {
+            limit_name: {
+                type: 'string',
+                description: 'Name of the aggregate limit to watch (must match a limit_warnings.name entry, e.g. "databases", "members")',
+            },
+            entity_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column on the target table that holds the entity id for aggregate limit lookup',
+                default: 'entity_id',
+            },
+        },
+        required: ['limit_name'],
+    },
+    tags: ['limits', 'triggers', 'aggregates', 'warning', 'notifications'],
+};

package/limit/warning-counter.d.ts

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

package/limit/warning-counter.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LimitWarningCounter = void 0;
+exports.LimitWarningCounter = {
+    name: 'LimitWarningCounter',
+    slug: 'limit_warning_counter',
+    category: 'limit_warning',
+    display_name: 'Warning Counter',
+    description: 'Attaches an AFTER INSERT trigger that checks if the actor\'s current usage has crossed any warning threshold configured in the limit_warnings table. If a threshold is reached for the first time, enqueues a background job (e.g. email notification). Uses limit_warning_state for one-time dedup per warning/actor pair. Requires a provisioned limits_module with limit_warnings enabled.',
+    parameter_schema: {
+        type: 'object',
+        properties: {
+            limit_name: {
+                type: 'string',
+                description: 'Name of the limit to watch (must match a limit_warnings.name 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 id for limit lookup',
+                default: 'owner_id',
+            },
+        },
+        required: ['limit_name'],
+    },
+    tags: ['limits', 'triggers', 'warning', 'notifications'],
+};

package/limit/warning-rate.d.ts

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