better-supabase 0.14.0 → 0.15.0

package/dist/index-CguFm716.d.ts

@@ -0,0 +1,518 @@
+import { E as AccessPolicySql } from "./types-DFdg_4yN.js";
+import { p as AnyBlocksConfig, t as AuthorizationFunctions } from "./authorization-HZdJCaVm.js";
+import { tt as ReadSet } from "./define-DFBnQyYg.js";
+import { Ar as CatalogPolicy, T as TableGrant, Zt as ResolvedConfig, _ as BlockSqlDeprecation, b as BlockSqlLayout, c as BlockSqlIdType, g as BlockSqlAccessProvider, h as BlockSql, mr as AppTableConfig, o as BlockSqlContractFunction, v as BlockSqlEntitlementsProvider, y as BlockSqlFile } from "./context-CEuTKrkz.js";
+import { t as SubjectConfig } from "./subjects-DvmQeF_F.js";
+//#region src/sql/render.d.ts
+/** A module's SQL for `layout`, without header; `undefined` in custom mode. */
+declare function moduleBody(name: string, layout?: BlockSqlLayout): string | undefined;
+/**
+ * The files `add` writes for these modules. Modules in `custom` mode write
+ * nothing: the app implements their contract. A schema module's rows, role
+ * settings and other statements a schema diff can't capture go to a second file
+ * in `better-supabase-data/` (`kind: 'data'`), which `add --adopt` writes into
+ * a migration. An instance that installs a module under another name renders
+ * its own files after the module's.
+ */
+declare function renderBlocks(names: readonly string[], layout?: BlockSqlLayout): BlockSqlFile[];
+interface BlockSqlTopic {
+  readonly module: string;
+  readonly topic: string;
+}
+declare function moduleTopics(names: readonly string[], layout?: BlockSqlLayout): BlockSqlTopic[];
+/** The contract functions of the modules in `custom` mode, for doctor. */
+declare function customContracts(names: readonly string[], layout?: BlockSqlLayout): {
+  readonly module: string;
+  readonly schema: string;
+  readonly idType: BlockSqlIdType;
+  readonly functions: readonly BlockSqlContractFunction[];
+}[];
+//#endregion
+//#region src/sql/upgrade.d.ts
+/**
+ * An installed module, from its file's `@bsb-block` line or the
+ * `better_supabase.blocks` table.
+ */
+interface InstalledBlock {
+  /** The instance: the module's name, or the key of a renamed instance. */
+  readonly module: string;
+  /** The module, when the instance installs it under another name. */
+  readonly block?: string;
+  readonly version: number;
+}
+/** What `upgrade` runs for one instance behind the current version. */
+interface BlockSqlUpgradePlan {
+  /** The instance. */
+  readonly module: string;
+  readonly from: number;
+  readonly to: number;
+  readonly steps: readonly {
+    readonly from: number;
+    readonly description: string;
+    readonly sql: string;
+  }[];
+}
+/**
+ * The upgrade steps for modules installed at an older version. A version
+ * without a step needs none: the module file upgrades in place. Modules in
+ * custom mode belong to the app and are skipped.
+ */
+declare function upgradePlan(installed: readonly InstalledBlock[], layout?: BlockSqlLayout, modules?: Readonly<Record<string, BlockSql>>): BlockSqlUpgradePlan[];
+/** Every deprecated or removed module symbol, with its module. */
+declare function moduleDeprecations(modules?: Readonly<Record<string, BlockSql>>): readonly (BlockSqlDeprecation & {
+  readonly module: string;
+})[];
+//#endregion
+//#region src/sql/block-renames.d.ts
+/**
+ * The blocks 0.15 renamed to plain defaults (ADR 0093), from the 0.14 name to
+ * the 0.15 one. `upgrade` moves an installed block to its new name, the config
+ * names the new one for an old key, and `codemod 0.15` rewrites both.
+ */
+declare const BLOCK_RENAMES: Readonly<Record<string, string>>;
+/** The 0.15 name of a block 0.15 renamed, or `undefined`. */
+declare function renamedBlock(name: string): string | undefined;
+/** The 0.14 name of a block 0.15 renamed, or `undefined`. */
+declare function formerBlockName(name: string): string | undefined;
+/** `name` under its 0.15 name. */
+declare const currentBlockName: (name: string) => string;
+//#endregion
+//#region src/sql/entity-upgrade.d.ts
+/** One statement `upgrade` runs to move an installed block to new names. */
+interface EntityRenameStep {
+  readonly module: string;
+  readonly description: string;
+  readonly sql: string;
+}
+/** The renames for changed `blocks.<name>.entities`, or why they can't run. */
+interface EntityRenamePlan {
+  readonly steps: readonly EntityRenameStep[];
+  /** One message per module whose objects don't pair up between the names. */
+  readonly refused: readonly string[];
+}
+/**
+ * The statements that move installed blocks from the entity names their files
+ * carry (`@bsb-names`) to the names `layout` gives them: tables, columns,
+ * indexes, policies, triggers and functions are renamed in place, permission
+ * keys keep their grants, and stored subject types follow. `installedText` is
+ * the installed module files or migration; `modules` the installed modules.
+ */
+declare function entityRenamePlan(names: readonly string[], modules: readonly string[], installedText: string, layout: BlockSqlLayout): EntityRenamePlan;
+//#endregion
+//#region src/sql/paths.d.ts
+/**
+ * The schema or test file `renderBlocks` writes for each of `names` and the
+ * modules they pull in, without rendering: modules in custom mode have none.
+ */
+declare function moduleFilePaths(names: readonly string[], layout?: BlockSqlLayout): ReadonlyMap<string, string>;
+/**
+ * The folder for module data statements: `better-supabase-data/` next to the
+ * declarative schema folder, or next to `dir` when `dir` is outside it.
+ * pg-delta loads every file under the schema folder, nested folders included,
+ * and rejects a managed table that has rows afterwards.
+ */
+declare function moduleDataDir(layout: BlockSqlLayout): string;
+//#endregion
+//#region src/sql/markers.d.ts
+/**
+ * The installed version of a module file, from its `@bsb-block` line: `module`
+ * is the instance, and `block` the block an instance with another name
+ * installs.
+ */
+declare function moduleFileVersion(contents: string): {
+  readonly module: string;
+  readonly block?: string;
+  readonly version: number;
+} | undefined;
+/** Whether `contents` is a data file `renderBlocks` wrote. */
+declare const isModuleDataFile: (contents: string) => boolean;
+/**
+ * Whether the hash line matches the body. `missing` is a file from before
+ * hashes, which sync may still rewrite. `edited` is a body someone changed
+ * without updating the hash.
+ */
+declare function blockFileState(contents: string): "clean" | "missing" | "edited";
+/**
+ * Whether an installed file matches, ignoring line endings and the version
+ * releases before 0.13 stamped in its header.
+ */
+declare function sameBlockFile(current: string | undefined, expected: string): boolean;
+//#endregion
+//#region src/sql/introspect.d.ts
+/** A permission key a SQL module checks, from `modulePermissionKeys`. */
+interface BlockSqlPermissionKey {
+  readonly module: string;
+  /** The action in `blocks.<module>.permissions` that overrides the key. */
+  readonly action: string;
+  readonly key: string;
+  /**
+   * `tenant` for keys checked in a tenant (`member_can`, `can`,
+   * `tenant_ids_with`), `platform` for `is_platform` and `platform_can`.
+   */
+  readonly scope: "tenant" | "platform";
+  readonly setting?: string;
+}
+/**
+ * Every permission key the modules `names` install (with what they pull in)
+ * check, after `blocks.<module>.permissions` overrides. Modules in custom mode
+ * are skipped, and so is `invitations.invitePlatform` without platform roles.
+ */
+declare function modulePermissionKeys(config: AnyBlocksConfig, names: readonly string[]): BlockSqlPermissionKey[];
+interface BlockSqlExtension {
+  readonly name: string;
+  readonly statement: string;
+}
+declare const moduleSchemaExtensions: (files: readonly BlockSqlFile[]) => BlockSqlExtension[];
+/**
+ * The installed modules' soft-delete columns (`BlockSql.hidingColumns`), as
+ * `schema.table.column` after the layout's renames, for doctor BS213.
+ */
+declare function moduleHidingColumns(installed: readonly string[], layout: BlockSqlLayout): string[];
+/**
+ * The event triggers each of these modules creates, as its default file renders
+ * them, for doctor's check of a database.
+ */
+declare function moduleEventTriggers(names: readonly string[], modules?: Readonly<Record<string, BlockSql>>): {
+  readonly module: string;
+  readonly name: string;
+}[];
+//#endregion
+//#region src/sql/registry.d.ts
+/** New modules go at the end: the position is part of the file name. */
+declare const SQL_MODULES: Readonly<Record<string, BlockSql>>;
+/**
+ * The modules to install for `names`, dependencies first. Throws on an unknown
+ * name.
+ */
+declare function resolveBlocks(names: readonly string[], layout?: BlockSqlLayout): BlockSql[];
+//#endregion
+//#region src/sql/instance-functions.d.ts
+/**
+ * Each function of `instance`'s block to the name the instance's SQL writes it
+ * under, for the functions it writes under another name: the instance's prefix,
+ * its entity renames and `blocks.<instance>.functions`. `gen` writes it to the
+ * instance's `names.functions`, so the block's client calls the instance's own
+ * functions.
+ */
+declare function instanceFunctions(layout: BlockSqlLayout, installed: readonly string[], instance: string): Readonly<Record<string, string>>;
+//#endregion
+//#region src/sql/modules/permissions-model.d.ts
+/**
+ * The `roles` model's defaults. Module actions name these keys (see
+ * `OPERATIONS`); `*` grants everything and `prefix.*` a prefix.
+ */
+declare const DEFAULT_ROLES: Readonly<Record<string, readonly string[]>>;
+//#endregion
+//#region src/sql/modules/app-tables.d.ts
+/**
+ * The `module` of the files `renderBlocks` writes for `appTables`. App tables
+ * aren't a block: no `SQL_MODULES` entry, no preset, no row in
+ * `better_supabase.blocks` (ADR 0040).
+ */
+declare const APP_TABLES_MODULE = "app-tables";
+/** The first line after the title of the app tables schema file. */
+declare const APP_TABLES_MARKER = "-- @bsb-tables";
+/**
+ * The files for `layout.appTables`: one schema file that creates every app
+ * table in `public` (implicit columns first, then each column with `add column
+ * if not exists`, so a later column reaches an existing table), with row level
+ * security, the grants and policies of its scope, indexes on the scope and
+ * reference columns, and the `updated_at` trigger when the `updated-at` block
+ * is installed; and one pgTAP file that checks the policies and grants. A table
+ * the app's own schema already creates (`layout.ownTables`) is enriched: only
+ * the columns it lacks are added, and the rest renders the same. Empty without
+ * app tables. `installed` is every block module `renderBlocks` resolved.
+ */
+declare function appTablesFiles(layout: BlockSqlLayout, installed: readonly string[]): BlockSqlFile[];
+//#endregion
+//#region src/sql/adopted-columns.d.ts
+/**
+ * A table of the app's that a module reads and writes (one `ownTables` lists,
+ * or a subject table it writes columns of), with the columns it uses.
+ */
+interface AdoptedTable {
+  readonly module: string;
+  readonly logical: string;
+  readonly schema: string;
+  readonly table: string;
+  /** Logical column to the physical column the module's SQL names. */
+  readonly columns: Readonly<Record<string, string>>;
+  /**
+   * Logical text columns a module writes a computed value into without
+   * `ctx.cast`, so the app's column must take a text value: an enum there
+   * fails. Columns written only with string literals are left out.
+   */
+  readonly textColumns: readonly string[];
+}
+/**
+ * Every table of the app's that the modules in `modules` use, because
+ * `ownTables` lists it or `blocks.<name>.on` names it, with the columns their
+ * SQL names: mapped to `null` and unused optional columns are left out.
+ */
+declare function adoptedTables(modules: AnyBlocksConfig, ownTables?: Readonly<Record<string, string>>): readonly AdoptedTable[];
+/**
+ * The columns the modules write on the app's other tables (`appSubjectTables`,
+ * such as a tag link table) that those tables lack, and the enum columns they
+ * write as text. `upgrade` refuses those configs. A column missing from a
+ * block's own logical table isn't one: the block adds it.
+ */
+declare function adoptedColumnProblems(modules: AnyBlocksConfig, files: readonly {
+  readonly text: string;
+}[], schemas: readonly string[], ownTables?: Readonly<Record<string, string>>): readonly string[];
+//#endregion
+//#region src/sql/expose-columns.d.ts
+/**
+ * The columns `privilege(*, -a, -b)` leaves out, unquoted. Empty for any other
+ * privilege.
+ */
+declare function excludedColumns(privilege: string): readonly string[];
+/**
+ * `grants` with every `privilege(*, -col)` turned into the explicit column list
+ * the `create table` in `files` declares, in declaration order. Throws for a
+ * table no file declares, or when the exclusions leave no column.
+ */
+declare function resolveExposeColumns(grants: readonly TableGrant[], files: readonly {
+  readonly text: string;
+}[], schemas: readonly string[]): readonly TableGrant[];
+//#endregion
+//#region src/sql/modules/data-lifecycle-secrets.d.ts
+/** Column names that usually hold a credential, matched case-insensitively. */
+declare const SECRET_COLUMNS = "token|secret|_hash|password|api_key|license_key";
+/** What doctor needs to tell which columns a data export reads. */
+interface DataExportPlan {
+  /**
+   * The listed and module tables an export reads, `schema.table`, with the
+   * columns it leaves out.
+   */
+  readonly tables: readonly {
+    readonly name: string;
+    readonly omit: readonly string[];
+  }[];
+  /**
+   * `options.autoTables`: the tables in `schemas` with one of `columns`, minus
+   * `excluded` and the listed ones.
+   */
+  readonly auto: {
+    readonly schemas: readonly string[];
+    readonly columns: readonly string[];
+    readonly excluded: (name: string) => boolean;
+  } | undefined;
+  /** `options.omitPattern`, resolved. */
+  readonly omitPattern: string | undefined;
+}
+/** The export tables for doctor. Undefined without the `data-lifecycle` module. */
+declare function dataExportPlan(layout: BlockSqlLayout, installed: readonly string[]): DataExportPlan | undefined;
+//#endregion
+//#region src/sql/modules/tenant-same.d.ts
+/**
+ * The unquoted trigger name `sameTenant` gives `column`, within Postgres' 63
+ * bytes.
+ */
+declare function sameTenantTrigger(column: string): string;
+/**
+ * The tenant column `sameTenant` entries default to: the memberships tenant
+ * column.
+ */
+declare function sameTenantColumn(layout: BlockSqlLayout): string;
+//#endregion
+//#region src/sql/flag-lifecycle.d.ts
+/**
+ * The flags past their `expires_at`, as doctor reads them: `expires_at` and
+ * `owner` are optional `extraColumns` of the flags table, and an archived flag
+ * is left out. Undefined when the flags module isn't installed or has no
+ * `expires_at` column.
+ */
+declare function expiredFlagsQuery(layout: BlockSqlLayout, installed: readonly string[]): string | undefined;
+//#endregion
+//#region src/sql/tenant-query.d.ts
+interface TenantQuery {
+  readonly text: string;
+  readonly values: readonly string[];
+}
+/**
+ * The organizations `seed --tenant` fills: the one whose slug or id is
+ * `tenant`, or every live one for `*`. Each row has `id`, `slug` and `name` as
+ * text. Undefined when the organizations module isn't installed.
+ */
+declare function tenantsQuery(layout: BlockSqlLayout, installed: readonly string[], tenant: string): TenantQuery | undefined;
+//#endregion
+//#region src/sql/subject-registry.d.ts
+/** Every column a registry entry names, keyed by the config path that names it. */
+declare function subjectColumns(entry: SubjectConfig): readonly (readonly [path: string, column: string])[];
+//#endregion
+//#region src/sql/schema-scan.d.ts
+/** Privileges one role gets on a table, from the policies that name it. */
+interface PolicyGrant {
+  /** `schema.table`, unquoted; an unqualified name is in `public`. */
+  readonly table: string;
+  readonly role: "anon" | "authenticated";
+  readonly privileges: readonly ("select" | "insert" | "update" | "delete")[];
+}
+/**
+ * The tables `files` create (`create table`), as `schema.table`, in the order
+ * they first appear. Only tables in `schemas` are kept.
+ */
+declare function declaredTables(files: readonly {
+  readonly text: string;
+}[], schemas: readonly string[]): string[];
+/**
+ * The tables in `schemas` that `files` leave with row level security on: `alter
+ * table ... enable row level security`, until a later `disable` or `drop
+ * table`.
+ */
+declare function rlsTables(files: readonly {
+  readonly text: string;
+}[], schemas: readonly string[]): string[];
+/**
+ * Columns each `create table` in `files` declares, as `schema.table` to
+ * unquoted names. `like` and table constraints are skipped. Only tables in
+ * `schemas` are kept.
+ */
+declare function declaredTableColumns(files: readonly {
+  readonly text: string;
+}[], schemas: readonly string[]): ReadonlyMap<string, ReadonlySet<string>>;
+/**
+ * The privileges the permissive policies in `files` imply, per table and role:
+ * `for all` gives the four commands, `to public` (or no `to`) counts for
+ * `authenticated` only, so `anon` needs a policy that names it. Restrictive
+ * policies grant nothing. Only tables in `schemas` are kept.
+ */
+declare function policyGrants(files: readonly {
+  readonly text: string;
+}[], schemas: readonly string[]): PolicyGrant[];
+declare function extensionSchema(sources: readonly {
+  readonly text: string;
+}[], extension: string): string | undefined;
+/**
+ * The update trigger that keeps `updated_at` current on each table in `schemas`
+ * the files create one on, by `schema.table`: its function is named like one
+ * (`set_updated_at`, `moddatetime`, `touch_*`) or the files define it with
+ * `new.updated_at :=`. Block triggers (`bsb_*`) don't count.
+ */
+declare function declaredUpdatedAtTriggers(files: readonly {
+  readonly text: string;
+}[], schemas: readonly string[]): Readonly<Record<string, string>>;
+//#endregion
+//#region src/core/access-sql.d.ts
+/** The Postgres types a scope's ids can have. */
+declare const SCOPE_ID_TYPES: readonly string[];
+/**
+ * What is wrong with a provider's scopes: an unknown tenant scope or parent, a
+ * parent cycle, an id type outside `SCOPE_ID_TYPES`, or a tenant scope without
+ * one.
+ */
+declare function scopeProblems(provider: {
+  readonly scopes: readonly {
+    readonly name: string;
+    readonly idType?: string | undefined;
+    readonly parent?: string | undefined;
+  }[];
+  readonly tenantScope: string;
+}): string[];
+/**
+ * The `schema.name` of every schema-qualified function a template calls, with
+ * `{scope}` filled.
+ */
+declare function templateFunctions(template: string, scope?: string): string[];
+/** What a bucket or topic access policy decides with. */
+interface AccessTarget {
+  /** `tenant` (default), `platform`, or with `sql` any scope its templates take. */
+  readonly scope?: string;
+  /** `"provider"` is replaced with `authorization.functions` by `gen`. */
+  readonly sql?: AccessPolicySql | "provider";
+}
+/**
+ * `target` with `sql: "provider"` replaced by the provider's `idsWith` and
+ * `isPlatform`. `where` names the policy in the error when there is no
+ * provider.
+ */
+declare function resolveProviderSql<T extends AccessTarget>(where: string, target: T, functions: AuthorizationFunctions | undefined): T;
+//#endregion
+//#region src/sql/layout.d.ts
+/** Where and how `add` writes module files for this config. */
+declare function moduleLayout(config: ResolvedConfig, testsDir?: string, readSets?: BlockSqlLayout["readSets"], entitlementsProvider?: BlockSqlEntitlementsProvider, accessProvider?: BlockSqlAccessProvider, permissionCatalog?: readonly string[]): BlockSqlLayout;
+//#endregion
+//#region src/sql/migration-options.d.ts
+/** A migration-only option a config sets. */
+interface MigrationOptionUse {
+  readonly module: string;
+  readonly option: string;
+  readonly value: unknown;
+  /** `blocks.<module>.options.<option> ... It <effect>.` */
+  readonly message: string;
+}
+/**
+ * The migration-only options `blocks` sets to a value other than the managed
+ * default. They are accepted only for a block over a table the app already has;
+ * doctor warns about each.
+ */
+declare function migrationOptionUses(modules?: AnyBlocksConfig): MigrationOptionUse[];
+//#endregion
+//#region src/sql/shared-roles.d.ts
+/**
+ * Why a roles table that holds both tenant and platform roles (the tenant
+ * module's `roleThrough` and the invitations module's `platformRoles.through`
+ * under the `provider` model) can't tell them apart: the setting that lacks
+ * `where` and why. Empty when the modules don't share a roles table.
+ */
+declare function sharedRolesProblems(names: readonly string[], layout: BlockSqlLayout): {
+  readonly setting: string;
+  readonly message: string;
+}[];
+//#endregion
+//#region src/sql/read-sets.d.ts
+/** A read set compiled to the SQL of its function. */
+interface CompiledReadSet {
+  readonly name: string;
+  readonly sql: string;
+}
+/**
+ * The function for a read set: `stable`, `security invoker` (RLS applies to the
+ * caller) and with an empty `search_path`. Parameters are read from the `p
+ * jsonb` argument; nothing is built dynamically.
+ */
+declare function compileReadSet(set: ReadSet): Promise<CompiledReadSet>;
+/** Compiles every set, sorted by name. Throws on a duplicate name. */
+declare function compileReadSets(sets: readonly ReadSet[]): Promise<CompiledReadSet[]>;
+//#endregion
+//#region src/config/app-access.d.ts
+/** Whether `table` grants by column: a column sets `access` or is encrypted. */
+declare function hasColumnAccess(table: AppTableConfig): boolean;
+//#endregion
+//#region src/sql/modules/app-table-enrich.d.ts
+/**
+ * The name of a scope policy. On the app's own table it carries the `bsb_`
+ * prefix, so it never replaces a policy the app wrote.
+ */
+declare const scopePolicyName: (table: {
+  readonly name: string;
+  readonly enrich?: unknown;
+}, command: string) => string;
+//#endregion
+//#region src/sql/tenant-scope.d.ts
+/**
+ * The restrictive policy that keeps each organization's rows apart (ADR 0099).
+ * Postgres combines permissive policies with `or`, so any permissive policy the
+ * app adds would widen a block's; a restrictive one is combined with `and`, so
+ * no permissive policy reaches past it.
+ */
+declare const TENANT_SCOPE_POLICY = "bsb_tenant_scope";
+//#endregion
+//#region src/sql/policy-cover.d.ts
+type PolicyCommand = "select" | "insert" | "update" | "delete";
+/**
+ * The commands `block` grants beyond the app's permissive policies: the app has
+ * a policy for the command and none of them covers the block's. A command the
+ * app has no policy for is the block's to grant.
+ */
+declare function widenedCommands(block: CatalogPolicy, apps: readonly CatalogPolicy[]): PolicyCommand[];
+/**
+ * The policies `sources` leave on each `schema.table` in `schemas`, in order: a
+ * later `drop policy` removes one, and a later `create policy` of the same name
+ * replaces it.
+ */
+declare function declaredPolicies(sources: readonly {
+  readonly text: string;
+}[], schemas: readonly string[]): Record<string, CatalogPolicy[]>;
+//#endregion
+export { moduleFileVersion as $, DataExportPlan as A, appTablesFiles as B, rlsTables as C, expiredFlagsQuery as D, tenantsQuery as E, AdoptedTable as F, BlockSqlExtension as G, instanceFunctions as H, adoptedColumnProblems as I, moduleHidingColumns as J, BlockSqlPermissionKey as K, adoptedTables as L, dataExportPlan as M, excludedColumns as N, sameTenantColumn as O, resolveExposeColumns as P, isModuleDataFile as Q, APP_TABLES_MARKER as R, policyGrants as S, TenantQuery as T, SQL_MODULES as U, DEFAULT_ROLES as V, resolveBlocks as W, moduleSchemaExtensions as X, modulePermissionKeys as Y, blockFileState as Z, PolicyGrant as _, moduleTopics as _t, hasColumnAccess as a, entityRenamePlan as at, declaredUpdatedAtTriggers as b, compileReadSets as c, formerBlockName as ct, migrationOptionUses as d, InstalledBlock as dt, sameBlockFile as et, moduleLayout as f, moduleDeprecations as ft, templateFunctions as g, moduleBody as gt, scopeProblems as h, customContracts as ht, scopePolicyName as i, EntityRenameStep as it, SECRET_COLUMNS as j, sameTenantTrigger as k, sharedRolesProblems as l, renamedBlock as lt, resolveProviderSql as m, BlockSqlTopic as mt, widenedCommands as n, moduleFilePaths as nt, CompiledReadSet as o, BLOCK_RENAMES as ot, SCOPE_ID_TYPES as p, upgradePlan as pt, moduleEventTriggers as q, TENANT_SCOPE_POLICY as r, EntityRenamePlan as rt, compileReadSet as s, currentBlockName as st, declaredPolicies as t, moduleDataDir as tt, MigrationOptionUse as u, BlockSqlUpgradePlan as ut, declaredTableColumns as v, renderBlocks as vt, subjectColumns as w, extensionSchema as x, declaredTables as y, APP_TABLES_MODULE as z };