node-type-registry 0.4.0 → 0.5.1

package/esm/blueprint-types.generated.d.ts

@@ -0,0 +1,659 @@
+/** Adds a UUID primary key column with auto-generation default (uuidv7). This is the standard primary key pattern for all tables. */
+export interface DataIdParams {
+    field_name?: string;
+}
+/** Adds ownership column for direct user ownership. Enables AuthzDirectOwner authorization. */
+export interface DataDirectOwnerParams {
+    owner_field_name?: string;
+    include_id?: boolean;
+    include_user_fk?: boolean;
+}
+/** Adds entity reference for organization/group scoping. Enables AuthzEntityMembership, AuthzMembership, AuthzOrgHierarchy authorization. */
+export interface DataEntityMembershipParams {
+    entity_field_name?: string;
+    include_id?: boolean;
+    include_user_fk?: boolean;
+}
+/** Combines direct ownership with entity scoping. Adds both owner_id and entity_id columns. Enables AuthzDirectOwner, AuthzEntityMembership, and AuthzOrgHierarchy authorization. Particularly useful for OrgHierarchy where a user owns a row (owner_id) within an entity (entity_id), and managers above can see subordinate-owned records via the hierarchy closure table. */
+export interface DataOwnershipInEntityParams {
+    include_id?: boolean;
+    include_user_fk?: boolean;
+}
+/** Adds automatic timestamp tracking with created_at and updated_at columns. */
+export interface DataTimestampsParams {
+    include_id?: boolean;
+}
+/** Adds user tracking for creates/updates with created_by and updated_by columns. */
+export interface DataPeoplestampsParams {
+    include_id?: boolean;
+    include_user_fk?: boolean;
+}
+/** Adds publish state columns (is_published, published_at) for content visibility. Enables AuthzPublishable and AuthzTemporal authorization. */
+export interface DataPublishableParams {
+    include_id?: boolean;
+}
+/** Adds soft delete support with deleted_at and is_deleted columns. */
+export interface DataSoftDeleteParams {
+    include_id?: boolean;
+}
+/** Adds a vector embedding column with HNSW or IVFFlat index for similarity search. Supports configurable dimensions, distance metrics (cosine, l2, ip), stale tracking strategies (column, null, hash), and automatic job enqueue triggers for embedding generation. */
+export interface DataEmbeddingParams {
+    field_name?: string;
+    dimensions?: number;
+    index_method?: "hnsw" | "ivfflat";
+    metric?: "cosine" | "l2" | "ip";
+    index_options?: {
+        [key: string]: unknown;
+    };
+    include_stale_field?: boolean;
+    source_fields?: string[];
+    enqueue_job?: boolean;
+    job_task_name?: string;
+    stale_strategy?: "column" | "null" | "hash";
+}
+/** Adds a tsvector column with GIN index and automatic trigger population from source fields. Enables PostgreSQL full-text search with configurable weights and language support. Leverages the existing metaschema full_text_search infrastructure. */
+export interface DataFullTextSearchParams {
+    field_name?: string;
+    source_fields: {
+        field: string;
+        weight?: "A" | "B" | "C" | "D";
+        lang?: string;
+    }[];
+    search_score_weight?: number;
+}
+/** Creates a BM25 index on an existing text column using pg_textsearch. Enables statistical relevance ranking with configurable k1 and b parameters. The BM25 index is auto-detected by graphile-search. */
+export interface DataBm25Params {
+    field_name: string;
+    text_config?: string;
+    k1?: number;
+    b?: number;
+    search_score_weight?: number;
+}
+/** Composite node type that orchestrates multiple search modalities (full-text search, BM25, embeddings, trigram) on a single table. Configures per-table search score weights, normalization strategy, and recency boost via the @searchConfig smart tag. */
+export interface DataSearchParams {
+    full_text_search?: {
+        field_name?: string;
+        source_fields?: {
+            field: string;
+            weight?: "A" | "B" | "C" | "D";
+            lang?: string;
+        }[];
+        search_score_weight?: number;
+    };
+    bm25?: {
+        field_name?: string;
+        text_config?: string;
+        k1?: number;
+        b?: number;
+        search_score_weight?: number;
+    };
+    embedding?: {
+        field_name?: string;
+        dimensions?: number;
+        index_method?: "hnsw" | "ivfflat";
+        metric?: "cosine" | "l2" | "ip";
+        source_fields?: string[];
+        search_score_weight?: number;
+    };
+    trgm_fields?: string[];
+    search_config?: {
+        weights?: {
+            [key: string]: unknown;
+        };
+        normalization?: "linear" | "sigmoid";
+        boost_recent?: boolean;
+        boost_recency_field?: string;
+        boost_recency_decay?: number;
+    };
+}
+/** Adds a PostGIS geometry or geography column with a spatial index (GiST or SP-GiST). Supports configurable geometry types (Point, Polygon, etc.), SRID, and dimensionality. The graphile-postgis plugin auto-detects geometry/geography columns by codec type for spatial filtering (ST_Contains, ST_DWithin, bbox operators). */
+export interface DataPostGISParams {
+    field_name?: string;
+    geometry_type?: "Point" | "LineString" | "Polygon" | "MultiPoint" | "MultiLineString" | "MultiPolygon" | "GeometryCollection" | "Geometry";
+    srid?: number;
+    dimension?: 2 | 3 | 4;
+    use_geography?: boolean;
+    index_method?: "gist" | "spgist";
+}
+/** Creates a derived/materialized geometry field on the parent table that automatically aggregates geometries from a source (child) table via triggers. When child rows are inserted/updated/deleted, the parent aggregate field is recalculated using the specified PostGIS aggregation function (ST_Union, ST_Collect, ST_ConvexHull, ST_ConcaveHull). Useful for materializing spatial boundaries from collections of points or polygons. */
+export interface DataPostGISAggregateParams {
+    field_name?: string;
+    source_table_id: string;
+    source_geom_field?: string;
+    source_fk_field: string;
+    aggregate_function?: "union" | "collect" | "convex_hull" | "concave_hull";
+    geometry_type?: "Point" | "LineString" | "Polygon" | "MultiPoint" | "MultiLineString" | "MultiPolygon" | "GeometryCollection" | "Geometry";
+    srid?: number;
+    dimension?: 2 | 3 | 4;
+    use_geography?: boolean;
+    index_method?: "gist" | "spgist";
+}
+/** 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). */
+export interface DataJobTriggerParams {
+    task_identifier: string;
+    payload_strategy?: "row" | "row_id" | "fields" | "custom";
+    payload_fields?: string[];
+    payload_custom?: {
+        [key: string]: unknown;
+    };
+    events?: ("INSERT" | "UPDATE" | "DELETE")[];
+    include_old?: boolean;
+    include_meta?: boolean;
+    condition_field?: string;
+    condition_value?: string;
+    watch_fields?: string[];
+    job_key?: string;
+    queue_name?: string;
+    priority?: number;
+    run_at_delay?: string;
+    max_attempts?: number;
+}
+/** Adds a citext[] tags column with GIN index for efficient array containment queries (@>, &&). Standard tagging pattern for categorization and filtering. */
+export interface DataTagsParams {
+    field_name?: string;
+    default_value?: string;
+    is_required?: boolean;
+}
+/** Adds a status column with B-tree index for efficient equality filtering and sorting. Optionally constrains values via CHECK constraint when allowed_values is provided. */
+export interface DataStatusFieldParams {
+    field_name?: string;
+    type?: string;
+    default_value?: string;
+    is_required?: boolean;
+    allowed_values?: string[];
+}
+/** Adds a JSONB column with optional GIN index for containment queries (@>, ?, ?|, ?&). Standard pattern for semi-structured metadata. */
+export interface DataJsonbParams {
+    field_name?: string;
+    default_value?: string;
+    is_required?: boolean;
+    create_index?: boolean;
+}
+/** Creates GIN trigram indexes (gin_trgm_ops) on specified text/citext fields for fuzzy LIKE/ILIKE/similarity search. Adds @trgmSearch smart tag for PostGraphile integration. Fields must already exist on the table. */
+export interface DataTrgmParams {
+    fields: string[];
+}
+/** Auto-generates URL-friendly slugs from field values on insert/update. Attaches BEFORE INSERT and BEFORE UPDATE triggers that call inflection.slugify() on the target field. References fields by name in data jsonb. */
+export interface DataSlugParams {
+    field_name: string;
+    source_field_name?: string;
+}
+/** Transforms field values using inflection operations (snake_case, camelCase, slugify, plural, singular, etc). Attaches BEFORE INSERT and BEFORE UPDATE triggers. References fields by name in data jsonb. */
+export interface DataInflectionParams {
+    field_name: string;
+    ops: ("plural" | "singular" | "camel" | "pascal" | "dashed" | "slugify" | "underscore" | "lower" | "upper")[];
+}
+/** Restricts which user can modify specific columns in shared objects. Creates an AFTER UPDATE trigger that throws OWNED_PROPS when a non-owner tries to change protected fields. References fields by name in data jsonb. */
+export interface DataOwnedFieldsParams {
+    role_key_field_name: string;
+    protected_field_names: string[];
+}
+/** BEFORE INSERT trigger that copies specified fields from a parent table via a foreign key. The parent row is looked up through RLS (SECURITY INVOKER), so the insert fails if the caller cannot see the parent. Used by the storage module to inherit owner_id and is_public from buckets to files. */
+export interface DataInheritFromParentParams {
+    parent_fk_field: string;
+    fields: string[];
+    parent_table?: string;
+    parent_schema?: string;
+}
+/** BEFORE INSERT trigger that forces a field to the value of jwt_public.current_user_id(). Prevents clients from spoofing the actor/uploader identity. The field value is always overwritten regardless of what the client provides. */
+export interface DataForceCurrentUserParams {
+    field_name?: string;
+}
+/** BEFORE UPDATE trigger that prevents changes to a list of specified fields after INSERT. Raises an exception if any of the listed fields have changed. Unlike FieldImmutable (single-field), this handles multiple fields in a single trigger for efficiency. */
+export interface DataImmutableFieldsParams {
+    fields: string[];
+}
+/** Creates a user profiles table with standard profile fields (profile_picture, bio, first_name, last_name, tags, desired). Uses AuthzDirectOwner for edit access and AuthzAllowAll for select. */
+export type TableUserProfilesParams = {};
+/** Creates an organization settings table with standard business fields (legal_name, address fields). Uses AuthzEntityMembership for access control. */
+export type TableOrganizationSettingsParams = {};
+/** Creates a user settings table for user-specific configuration. Uses AuthzDirectOwner for access control. */
+export type TableUserSettingsParams = {};
+/** Direct equality comparison between a table column and the current user ID. Simplest authorization pattern with no subqueries. */
+export interface AuthzDirectOwnerParams {
+    entity_field: string;
+}
+/** OR logic for multiple ownership fields. Checks if current user matches any of the specified fields. */
+export interface AuthzDirectOwnerAnyParams {
+    entity_fields: string[];
+}
+/** Membership check that verifies the user has membership (optionally with specific permission) without binding to any entity from the row. Uses EXISTS subquery against SPRT table. */
+export interface AuthzMembershipParams {
+    membership_type: number | string;
+    permission?: string;
+    permissions?: string[];
+    is_admin?: boolean;
+    is_owner?: boolean;
+}
+/** Membership check scoped by a field on the row through the SPRT table. Verifies user has membership in the entity referenced by the row. */
+export interface AuthzEntityMembershipParams {
+    entity_field: string;
+    membership_type?: number | string;
+    permission?: string;
+    permissions?: string[];
+    is_admin?: boolean;
+    is_owner?: boolean;
+}
+/** JOIN-based membership verification through related tables. Joins SPRT table with another table to verify membership. */
+export interface AuthzRelatedEntityMembershipParams {
+    entity_field: string;
+    membership_type?: number | string;
+    obj_table_id?: string;
+    obj_schema?: string;
+    obj_table?: string;
+    obj_field_id?: string;
+    obj_field?: string;
+    permission?: string;
+    permissions?: string[];
+    is_admin?: boolean;
+    is_owner?: boolean;
+}
+/** Organizational hierarchy visibility using closure table. Managers can see subordinate data or subordinates can see manager data. */
+export interface AuthzOrgHierarchyParams {
+    direction: "up" | "down";
+    entity_field?: string;
+    anchor_field: string;
+    max_depth?: number;
+}
+/** Time-window based access control. Restricts access based on valid_from and/or valid_until timestamps. At least one of valid_from_field or valid_until_field must be provided. */
+export interface AuthzTemporalParams {
+    valid_from_field?: string;
+    valid_until_field?: string;
+    valid_from_inclusive?: boolean;
+    valid_until_inclusive?: boolean;
+}
+/** Published state access control. Restricts access to records that are published. */
+export interface AuthzPublishableParams {
+    is_published_field?: string;
+    published_at_field?: string;
+    require_published_at?: boolean;
+}
+/** Check if current user is in an array column on the same row. */
+export interface AuthzMemberListParams {
+    array_field: string;
+}
+/** Array membership check in a related table. */
+export interface AuthzRelatedMemberListParams {
+    owned_schema: string;
+    owned_table: string;
+    owned_table_key: string;
+    owned_table_ref_key: string;
+    this_object_key: string;
+}
+/** Allows all access. Generates TRUE expression. */
+export type AuthzAllowAllParams = {};
+/** Denies all access. Generates FALSE expression. */
+export type AuthzDenyAllParams = {};
+/** Composite authorization policy that combines multiple authorization nodes using boolean logic (AND/OR). The data field contains a JSONB AST with nested authorization nodes. */
+export interface AuthzCompositeParams {
+    BoolExpr?: {
+        boolop?: "AND_EXPR" | "OR_EXPR" | "NOT_EXPR";
+        args?: {
+            [key: string]: unknown;
+        }[];
+    };
+}
+/** Peer visibility through shared entity membership. Authorizes access to user-owned rows when the owner and current user are both members of the same entity. Self-joins the SPRT table to find peers. */
+export interface AuthzPeerOwnershipParams {
+    owner_field: string;
+    membership_type?: number | string;
+    permission?: string;
+    permissions?: string[];
+    is_admin?: boolean;
+    is_owner?: boolean;
+}
+/** Peer visibility through shared entity membership via a related table. Like AuthzPeerOwnership but the owning user is resolved through a FK JOIN to a related table. Combines SPRT self-join with object table JOIN. */
+export interface AuthzRelatedPeerOwnershipParams {
+    entity_field: string;
+    membership_type?: number | string;
+    obj_table_id?: string;
+    obj_schema?: string;
+    obj_table?: string;
+    obj_field_id?: string;
+    obj_field?: string;
+    obj_ref_field?: string;
+    permission?: string;
+    permissions?: string[];
+    is_admin?: boolean;
+    is_owner?: boolean;
+}
+/** Creates a foreign key field on the source table referencing the target table. Auto-derives the FK field name from the target table name using inflection (e.g., projects derives project_id). delete_action is required and must be explicitly provided by the caller. */
+export interface RelationBelongsToParams {
+    source_table_id: string;
+    target_table_id: string;
+    field_name?: string;
+    delete_action: "c" | "r" | "n" | "d" | "a";
+    is_required?: boolean;
+}
+/** Creates a foreign key field with a unique constraint on the source table referencing the target table. Enforces 1:1 cardinality. Auto-derives the FK field name from the target table name using inflection. delete_action is required and must be explicitly provided by the caller. */
+export interface RelationHasOneParams {
+    source_table_id: string;
+    target_table_id: string;
+    field_name?: string;
+    delete_action: "c" | "r" | "n" | "d" | "a";
+    is_required?: boolean;
+}
+/** Creates a foreign key field on the target table referencing the source table. Inverse of RelationBelongsTo — same FK, different perspective. "projects has many tasks" creates tasks.project_id. Auto-derives the FK field name from the source table name using inflection. delete_action is required and must be explicitly provided by the caller. */
+export interface RelationHasManyParams {
+    source_table_id: string;
+    target_table_id: string;
+    field_name?: string;
+    delete_action: "c" | "r" | "n" | "d" | "a";
+    is_required?: boolean;
+}
+/** Creates a junction table between source and target tables with auto-derived naming and FK fields. The trigger creates a bare table (no implicit DataId or any node_type), adds FK fields to both tables, optionally creates a composite PK (use_composite_key), then forwards all security config to secure_table_provision as-is. The trigger never injects values the caller did not provide. Junction table FKs always CASCADE on delete. */
+export interface RelationManyToManyParams {
+    source_table_id: string;
+    target_table_id: string;
+    junction_table_id?: string;
+    junction_table_name?: string;
+    source_field_name?: string;
+    target_field_name?: string;
+    use_composite_key?: boolean;
+    node_type?: string;
+    node_data?: {
+        [key: string]: unknown;
+    };
+    grant_roles?: string[];
+    grant_privileges?: string[];
+    policy_type?: string;
+    policy_privileges?: string[];
+    policy_role?: string;
+    policy_permissive?: boolean;
+    policy_data?: {
+        [key: string]: unknown;
+    };
+}
+/** Simple column selection from a single source table. Projects all or specific fields. */
+export interface ViewTableProjectionParams {
+    source_table_id: string;
+    field_ids?: string[];
+    field_names?: string[];
+}
+/** Table projection with an Authz* filter baked into the view definition. The view only returns records matching the filter. */
+export interface ViewFilteredTableParams {
+    source_table_id: string;
+    filter_type: string;
+    filter_data?: {
+        [key: string]: unknown;
+    };
+    field_ids?: string[];
+    field_names?: string[];
+}
+/** View that joins multiple tables together. Supports INNER, LEFT, RIGHT, and FULL joins. */
+export interface ViewJoinedTablesParams {
+    primary_table_id: string;
+    primary_columns?: string[];
+    joins: {
+        table_id: string;
+        join_type?: "INNER" | "LEFT" | "RIGHT" | "FULL";
+        primary_field: string;
+        join_field: string;
+        columns?: string[];
+    }[];
+    field_ids?: string[];
+}
+/** View with GROUP BY and aggregate functions. Useful for summary/reporting views. */
+export interface ViewAggregatedParams {
+    source_table_id: string;
+    group_by_fields: string[];
+    aggregates: {
+        function: "COUNT" | "SUM" | "AVG" | "MIN" | "MAX";
+        field?: string;
+        alias: string;
+    }[];
+}
+/** Advanced view using composite AST for the query. Use when other node types are insufficient (CTEs, UNIONs, complex subqueries, etc.). */
+export interface ViewCompositeParams {
+    query_ast: {
+        [key: string]: unknown;
+    };
+}
+/** A custom field (column) to add to a blueprint table. */
+export interface BlueprintField {
+    /** The column name. */
+    name: string;
+    /** The PostgreSQL type (e.g., "text", "integer", "boolean", "uuid"). */
+    type: string;
+    /** Whether the column has a NOT NULL constraint. */
+    is_required?: boolean;
+    /** SQL default value expression (e.g., "true", "now()"). */
+    default_value?: string;
+    /** Comment/description for this field. */
+    description?: string;
+}
+/** An RLS policy entry for a blueprint table. */
+export interface BlueprintPolicy {
+    /** Authz* policy type name (e.g., "AuthzDirectOwner", "AuthzAllowAll"). */
+    $type: "AuthzDirectOwner" | "AuthzDirectOwnerAny" | "AuthzMembership" | "AuthzEntityMembership" | "AuthzRelatedEntityMembership" | "AuthzOrgHierarchy" | "AuthzTemporal" | "AuthzPublishable" | "AuthzMemberList" | "AuthzRelatedMemberList" | "AuthzAllowAll" | "AuthzDenyAll" | "AuthzComposite" | "AuthzPeerOwnership" | "AuthzRelatedPeerOwnership";
+    /** Role for this policy. Defaults to "authenticated". */
+    policy_role?: string;
+    /** Whether this policy is permissive (true) or restrictive (false). */
+    permissive?: boolean;
+    /** Optional custom name for this policy. */
+    policy_name?: string;
+    /** Privileges this policy applies to. */
+    privileges?: string[];
+    /** Policy-specific data (structure varies by policy type). */
+    data?: Record<string, unknown>;
+}
+/** A source field contributing to a full-text search tsvector column. */
+export interface BlueprintFtsSource {
+    /** Column name of the source field. */
+    field: string;
+    /** TSVector weight: "A", "B", "C", or "D". */
+    weight: string;
+    /** Language for text search. Defaults to "english". */
+    lang?: string;
+}
+/** A full-text search configuration for a blueprint table. */
+export interface BlueprintFullTextSearch {
+    /** Reference key of the table this full-text search belongs to. */
+    table_ref: string;
+    /** Name of the tsvector field on the table. */
+    field: string;
+    /** Source fields that feed into this tsvector. */
+    sources: BlueprintFtsSource[];
+}
+/** An index definition within a blueprint. */
+export interface BlueprintIndex {
+    /** Reference key of the table this index belongs to. */
+    table_ref: string;
+    /** Single column name for the index. Mutually exclusive with "columns". */
+    column?: string;
+    /** Array of column names for a multi-column index. Mutually exclusive with "column". */
+    columns?: string[];
+    /** Index access method (e.g., "BTREE", "GIN", "GIST", "HNSW", "BM25"). */
+    access_method: string;
+    /** Whether this is a unique index. */
+    is_unique?: boolean;
+    /** Optional custom name for the index. */
+    name?: string;
+    /** Operator classes for the index columns. */
+    op_classes?: string[];
+    /** Additional index-specific options. */
+    options?: Record<string, unknown>;
+}
+/** String shorthand -- just the node type name. */
+export type BlueprintNodeShorthand = "AuthzDirectOwner" | "AuthzDirectOwnerAny" | "AuthzMembership" | "AuthzEntityMembership" | "AuthzRelatedEntityMembership" | "AuthzOrgHierarchy" | "AuthzTemporal" | "AuthzPublishable" | "AuthzMemberList" | "AuthzRelatedMemberList" | "AuthzAllowAll" | "AuthzDenyAll" | "AuthzComposite" | "AuthzPeerOwnership" | "AuthzRelatedPeerOwnership" | "DataId" | "DataDirectOwner" | "DataEntityMembership" | "DataOwnershipInEntity" | "DataTimestamps" | "DataPeoplestamps" | "DataPublishable" | "DataSoftDelete" | "DataEmbedding" | "DataFullTextSearch" | "DataBm25" | "DataSearch" | "DataPostGIS" | "DataPostGISAggregate" | "DataJobTrigger" | "DataTags" | "DataStatusField" | "DataJsonb" | "DataTrgm" | "DataSlug" | "DataInflection" | "DataOwnedFields" | "DataInheritFromParent" | "DataForceCurrentUser" | "DataImmutableFields" | "TableUserProfiles" | "TableOrganizationSettings" | "TableUserSettings";
+/** Object form -- { $type, data } with typed parameters. */
+export type BlueprintNodeObject = {
+    $type: "AuthzDirectOwner";
+    data: AuthzDirectOwnerParams;
+} | {
+    $type: "AuthzDirectOwnerAny";
+    data: AuthzDirectOwnerAnyParams;
+} | {
+    $type: "AuthzMembership";
+    data: AuthzMembershipParams;
+} | {
+    $type: "AuthzEntityMembership";
+    data: AuthzEntityMembershipParams;
+} | {
+    $type: "AuthzRelatedEntityMembership";
+    data: AuthzRelatedEntityMembershipParams;
+} | {
+    $type: "AuthzOrgHierarchy";
+    data: AuthzOrgHierarchyParams;
+} | {
+    $type: "AuthzTemporal";
+    data: AuthzTemporalParams;
+} | {
+    $type: "AuthzPublishable";
+    data: AuthzPublishableParams;
+} | {
+    $type: "AuthzMemberList";
+    data: AuthzMemberListParams;
+} | {
+    $type: "AuthzRelatedMemberList";
+    data: AuthzRelatedMemberListParams;
+} | {
+    $type: "AuthzAllowAll";
+    data?: Record<string, never>;
+} | {
+    $type: "AuthzDenyAll";
+    data?: Record<string, never>;
+} | {
+    $type: "AuthzComposite";
+    data: AuthzCompositeParams;
+} | {
+    $type: "AuthzPeerOwnership";
+    data: AuthzPeerOwnershipParams;
+} | {
+    $type: "AuthzRelatedPeerOwnership";
+    data: AuthzRelatedPeerOwnershipParams;
+} | {
+    $type: "DataId";
+    data: DataIdParams;
+} | {
+    $type: "DataDirectOwner";
+    data: DataDirectOwnerParams;
+} | {
+    $type: "DataEntityMembership";
+    data: DataEntityMembershipParams;
+} | {
+    $type: "DataOwnershipInEntity";
+    data: DataOwnershipInEntityParams;
+} | {
+    $type: "DataTimestamps";
+    data: DataTimestampsParams;
+} | {
+    $type: "DataPeoplestamps";
+    data: DataPeoplestampsParams;
+} | {
+    $type: "DataPublishable";
+    data: DataPublishableParams;
+} | {
+    $type: "DataSoftDelete";
+    data: DataSoftDeleteParams;
+} | {
+    $type: "DataEmbedding";
+    data: DataEmbeddingParams;
+} | {
+    $type: "DataFullTextSearch";
+    data: DataFullTextSearchParams;
+} | {
+    $type: "DataBm25";
+    data: DataBm25Params;
+} | {
+    $type: "DataSearch";
+    data: DataSearchParams;
+} | {
+    $type: "DataPostGIS";
+    data: DataPostGISParams;
+} | {
+    $type: "DataPostGISAggregate";
+    data: DataPostGISAggregateParams;
+} | {
+    $type: "DataJobTrigger";
+    data: DataJobTriggerParams;
+} | {
+    $type: "DataTags";
+    data: DataTagsParams;
+} | {
+    $type: "DataStatusField";
+    data: DataStatusFieldParams;
+} | {
+    $type: "DataJsonb";
+    data: DataJsonbParams;
+} | {
+    $type: "DataTrgm";
+    data: DataTrgmParams;
+} | {
+    $type: "DataSlug";
+    data: DataSlugParams;
+} | {
+    $type: "DataInflection";
+    data: DataInflectionParams;
+} | {
+    $type: "DataOwnedFields";
+    data: DataOwnedFieldsParams;
+} | {
+    $type: "DataInheritFromParent";
+    data: DataInheritFromParentParams;
+} | {
+    $type: "DataForceCurrentUser";
+    data: DataForceCurrentUserParams;
+} | {
+    $type: "DataImmutableFields";
+    data: DataImmutableFieldsParams;
+} | {
+    $type: "TableUserProfiles";
+    data?: Record<string, never>;
+} | {
+    $type: "TableOrganizationSettings";
+    data?: Record<string, never>;
+} | {
+    $type: "TableUserSettings";
+    data?: Record<string, never>;
+};
+/** A node entry in a blueprint table. Either a string shorthand or a typed object. */
+export type BlueprintNode = BlueprintNodeShorthand | BlueprintNodeObject;
+/** A relation entry in a blueprint definition. */
+export type BlueprintRelation = {
+    $type: "RelationBelongsTo";
+    source_ref: string;
+    target_ref: string;
+} & Partial<RelationBelongsToParams> | {
+    $type: "RelationHasOne";
+    source_ref: string;
+    target_ref: string;
+} & Partial<RelationHasOneParams> | {
+    $type: "RelationHasMany";
+    source_ref: string;
+    target_ref: string;
+} & Partial<RelationHasManyParams> | {
+    $type: "RelationManyToMany";
+    source_ref: string;
+    target_ref: string;
+} & Partial<RelationManyToManyParams>;
+/** A table definition within a blueprint. */
+export interface BlueprintTable {
+    /** Local reference key for this table (used by relations, indexes, fts). */
+    ref: string;
+    /** The PostgreSQL table name to create. */
+    table_name: string;
+    /** Array of node type entries that define the table's behavior. */
+    nodes: BlueprintNode[];
+    /** Custom fields (columns) to add to the table. */
+    fields?: BlueprintField[];
+    /** RLS policies for this table. */
+    policies?: BlueprintPolicy[];
+    /** Database roles to grant privileges to. Defaults to ["authenticated"]. */
+    grant_roles?: string[];
+    /** Privilege grants as [verb, column] tuples or objects. */
+    grants?: unknown[];
+    /** Whether to enable RLS on this table. Defaults to true. */
+    use_rls?: boolean;
+}
+/** The complete blueprint definition -- the JSONB shape accepted by construct_blueprint(). */
+export interface BlueprintDefinition {
+    /** Tables to create. */
+    tables: BlueprintTable[];
+    /** Relations between tables. */
+    relations?: BlueprintRelation[];
+    /** Indexes on table columns. */
+    indexes?: BlueprintIndex[];
+    /** Full-text search configurations. */
+    full_text_searches?: BlueprintFullTextSearch[];
+}