@wordrhyme/db 0.1.0-alpha.14

package/dist/chunk-3TTVLSF5.js

@@ -0,0 +1,3390 @@
+import {
+  TagPrefix,
+  __export,
+  createLbacIndexes,
+  lbacFields,
+  ownerFields,
+  permissionFields,
+  scopeFields
+} from "./chunk-KWWJRUIK.js";
+
+// src/schema/index.ts
+var schema_exports = {};
+__export(schema_exports, {
+  ACTION_JOURNAL_ACTIVE_STATUSES: () => ACTION_JOURNAL_ACTIVE_STATUSES,
+  ACTION_JOURNAL_STATUSES: () => ACTION_JOURNAL_STATUSES,
+  AccessLevel: () => AccessLevel,
+  CREDENTIAL_ACCOUNT_ISSUER: () => CREDENTIAL_ACCOUNT_ISSUER,
+  ENTITY_EXTENSION_PROJECTION_STATUSES: () => ENTITY_EXTENSION_PROJECTION_STATUSES,
+  ENTITY_EXTENSION_VALUE_TYPES: () => ENTITY_EXTENSION_VALUE_TYPES,
+  I18N_MESSAGE_FORMATS: () => I18N_MESSAGE_FORMATS,
+  MARKET_REGIONS: () => MARKET_REGIONS,
+  NotificationTypeEnum: () => NotificationTypeEnum,
+  PLUGIN_INSTALL_JOB_STATUSES: () => PLUGIN_INSTALL_JOB_STATUSES,
+  PLUGIN_INSTALL_OPERATIONS: () => PLUGIN_INSTALL_OPERATIONS,
+  PLUGIN_INSTALL_SOURCES: () => PLUGIN_INSTALL_SOURCES,
+  PLUGIN_MARKETPLACE_STATES: () => PLUGIN_MARKETPLACE_STATES,
+  PLUGIN_TRUST_LEVELS: () => PLUGIN_TRUST_LEVELS,
+  ROLE_PERMISSIONS: () => ROLE_PERMISSIONS,
+  SYS_INBOX_CODE: () => SYS_INBOX_CODE,
+  ScopeType: () => ScopeType,
+  TagPrefix: () => TagPrefix,
+  WEB_DOMAIN_CERTIFICATE_STATUSES: () => WEB_DOMAIN_CERTIFICATE_STATUSES,
+  WEB_DOMAIN_STATUSES: () => WEB_DOMAIN_STATUSES,
+  WEB_PAGE_RESERVED_PATHS: () => WEB_PAGE_RESERVED_PATHS,
+  WEB_PAGE_RESERVED_PREFIXES: () => WEB_PAGE_RESERVED_PREFIXES,
+  WEB_PAGE_STATUSES: () => WEB_PAGE_STATUSES,
+  WEB_THEME_REVISION_STATUSES: () => WEB_THEME_REVISION_STATUSES,
+  WEB_THEME_SELECTION_STATUSES: () => WEB_THEME_SELECTION_STATUSES,
+  account: () => account,
+  accountSchema: () => accountSchema,
+  actionExecutionJournal: () => actionExecutionJournal,
+  actionExecutionOutbox: () => actionExecutionOutbox,
+  activateWebThemeMutation: () => activateWebThemeMutation,
+  activateWebThemeRevisionMutation: () => activateWebThemeRevisionMutation,
+  apikey: () => apikey,
+  apikeySchema: () => apikeySchema,
+  appendPluginUploadMutation: () => appendPluginUploadMutation,
+  auditEventSchema: () => auditEventSchema,
+  auditEvents: () => auditEvents,
+  auditEventsArchive: () => auditEventsArchive,
+  auditEventsArchiveSchema: () => auditEventsArchiveSchema,
+  auditLogSchema: () => auditLogSchema,
+  auditLogs: () => auditLogs,
+  auditLogsArchive: () => auditLogsArchive,
+  auditLogsArchiveSchema: () => auditLogsArchiveSchema,
+  batchUpdateMessagesMutation: () => batchUpdateMessagesMutation,
+  billingEventOutbox: () => billingEventOutbox,
+  billingEventOutboxSchema: () => billingEventOutboxSchema,
+  capabilities: () => capabilities,
+  capabilitySchema: () => capabilitySchema,
+  checkFeatureFlagQuery: () => checkFeatureFlagQuery,
+  completePluginUploadMutation: () => completePluginUploadMutation,
+  countryCode2Schema: () => countryCode2Schema,
+  countryCode3Schema: () => countryCode3Schema,
+  createLbacIndexes: () => createLbacIndexes,
+  createMenuSchema: () => createMenuSchema,
+  createPluginUploadMutation: () => createPluginUploadMutation,
+  createWebDomainMutation: () => createWebDomainMutation,
+  createWebPageMutation: () => createWebPageMutation,
+  currencies: () => currencies,
+  currencySchema: () => currencySchema,
+  deleteFeatureFlagMutation: () => deleteFeatureFlagMutation,
+  deleteMenuMutation: () => deleteMenuMutation,
+  deleteSettingMutation: () => deleteSettingMutation,
+  deleteWebDomainMutation: () => deleteWebDomainMutation,
+  disableWebDomainMutation: () => disableWebDomainMutation,
+  entityOwnershipSchema: () => entityOwnershipSchema,
+  entityOwnerships: () => entityOwnerships,
+  exchangeRateSchema: () => exchangeRateSchema,
+  exchangeRates: () => exchangeRates,
+  extProjection: () => extProjection,
+  featureFlagOverrideSchema: () => featureFlagOverrideSchema,
+  featureFlagOverrides: () => featureFlagOverrides,
+  featureFlagSchema: () => featureFlagSchema,
+  featureFlags: () => featureFlags,
+  flagConditionSchema: () => flagConditionSchema,
+  geoCountries: () => geoCountries,
+  geoCountrySchema: () => geoCountrySchema,
+  geoNameSchema: () => geoNameSchema,
+  geoSubdivisionSchema: () => geoSubdivisionSchema,
+  geoSubdivisions: () => geoSubdivisions,
+  getFeatureFlagQuery: () => getFeatureFlagQuery,
+  getGeoCountryQuery: () => getGeoCountryQuery,
+  getGeoSubdivisionQuery: () => getGeoSubdivisionQuery,
+  getI18nBundlesQuery: () => getI18nBundlesQuery,
+  getI18nBundlesResultSchema: () => getI18nBundlesResultSchema,
+  getI18nMessagesQuery: () => getI18nMessagesQuery,
+  getMenuQuery: () => getMenuQuery,
+  getPluginInstallJobQuery: () => getPluginInstallJobQuery,
+  getSettingQuery: () => getSettingQuery,
+  getWebDomainQuery: () => getWebDomainQuery,
+  getWebPageDocumentQuery: () => getWebPageDocumentQuery,
+  getWebThemeQuery: () => getWebThemeQuery,
+  getWebThemeRevisionQuery: () => getWebThemeRevisionQuery,
+  i18nBundleSchema: () => i18nBundleSchema,
+  i18nBundleVersions: () => i18nBundleVersions,
+  i18nDirectionSchema: () => i18nDirectionSchema,
+  i18nLanguageSchema: () => i18nLanguageSchema,
+  i18nLanguages: () => i18nLanguages,
+  i18nMessageFormatSchema: () => i18nMessageFormatSchema,
+  i18nMessageSchema: () => i18nMessageSchema,
+  i18nMessageSourceSchema: () => i18nMessageSourceSchema,
+  i18nMessageTypeSchema: () => i18nMessageTypeSchema,
+  i18nMessages: () => i18nMessages,
+  importMediaFromUrlMutation: () => importMediaFromUrlMutation,
+  installPluginFromRegistryMutation: () => installPluginFromRegistryMutation,
+  invitation: () => invitation,
+  invitationSchema: () => invitationSchema,
+  issueWebThemePreviewMutation: () => issueWebThemePreviewMutation,
+  lbacFields: () => lbacFields,
+  listAllMenusQuery: () => listAllMenusQuery,
+  listFeatureFlagsQuery: () => listFeatureFlagsQuery,
+  listFlagOverridesQuery: () => listFlagOverridesQuery,
+  listGeoCountriesQuery: () => listGeoCountriesQuery,
+  listGeoSubdivisionsQuery: () => listGeoSubdivisionsQuery,
+  listI18nLanguagesQuery: () => listI18nLanguagesQuery,
+  listI18nMessagesQuery: () => listI18nMessagesQuery,
+  listMarketRegionsQuery: () => listMarketRegionsQuery,
+  listMenusQuery: () => listMenusQuery,
+  listPluginCatalogQuery: () => listPluginCatalogQuery,
+  listSettingsQuery: () => listSettingsQuery,
+  listWebThemeRevisionsQuery: () => listWebThemeRevisionsQuery,
+  localeSchema: () => localeSchema,
+  media: () => media,
+  mediaInsertSchema: () => mediaInsertSchema,
+  mediaSelectSchema: () => mediaSelectSchema,
+  member: () => member,
+  memberSchema: () => memberSchema,
+  menuSchema: () => menuSchema,
+  menus: () => menus,
+  notificationChannelSchema: () => notificationChannelSchema,
+  notificationChannels: () => notificationChannels,
+  notificationPreferenceSchema: () => notificationPreferenceSchema,
+  notificationPreferences: () => notificationPreferences,
+  notificationSchema: () => notificationSchema,
+  notificationTemplateSchema: () => notificationTemplateSchema,
+  notificationTemplates: () => notificationTemplates,
+  notifications: () => notifications,
+  organization: () => organization,
+  organizationSchema: () => organizationSchema,
+  ownerFields: () => ownerFields,
+  ownershipAuditLog: () => ownershipAuditLog,
+  ownershipAuditLogSchema: () => ownershipAuditLogSchema,
+  permissionFields: () => permissionFields,
+  permissionSchema: () => permissionSchema,
+  permissions: () => permissions,
+  planItemSchema: () => planItemSchema,
+  planItems: () => planItems,
+  planSchema: () => planSchema,
+  planSubscriptionSchema: () => planSubscriptionSchema,
+  planSubscriptions: () => planSubscriptions,
+  plans: () => plans,
+  pluginCatalogReleaseSchema: () => pluginCatalogReleaseSchema,
+  pluginCatalogReleases: () => pluginCatalogReleases,
+  pluginConfigSchema: () => pluginConfigSchema,
+  pluginConfigs: () => pluginConfigs,
+  pluginInstallJobSchema: () => pluginInstallJobSchema,
+  pluginInstallJobs: () => pluginInstallJobs,
+  pluginInstanceSchema: () => pluginInstanceSchema,
+  pluginInstances: () => pluginInstances,
+  pluginMigrationSchema: () => pluginMigrationSchema,
+  pluginMigrations: () => pluginMigrations,
+  pluginRegistrySyncState: () => pluginRegistrySyncState,
+  pluginSchema: () => pluginSchema,
+  plugins: () => plugins,
+  publishWebPageMutation: () => publishWebPageMutation,
+  publishWebThemeDraftMutation: () => publishWebThemeDraftMutation,
+  recoverWebThemeMutation: () => recoverWebThemeMutation,
+  relationship: () => relationship,
+  relationshipSchema: () => relationshipSchema,
+  removeFlagOverrideMutation: () => removeFlagOverrideMutation,
+  requestWebDomainCertificateMutation: () => requestWebDomainCertificateMutation,
+  rolePermissionSchema: () => rolePermissionSchema,
+  rolePermissions: () => rolePermissions,
+  roleSchema: () => roleSchema,
+  roles: () => roles,
+  rollbackPluginInstallMutation: () => rollbackPluginInstallMutation,
+  rollbackWebThemeRevisionMutation: () => rollbackWebThemeRevisionMutation,
+  saveWebPageDocumentMutation: () => saveWebPageDocumentMutation,
+  saveWebThemeDraftMutation: () => saveWebThemeDraftMutation,
+  scheduledTaskSchema: () => scheduledTaskSchema,
+  scheduledTasks: () => scheduledTasks,
+  schedulerProviderSchema: () => schedulerProviderSchema,
+  schedulerProviders: () => schedulerProviders,
+  scopeFields: () => scopeFields,
+  session: () => session,
+  sessionSchema: () => sessionSchema,
+  setDefaultLanguageMutation: () => setDefaultLanguageMutation,
+  setFlagOverrideMutation: () => setFlagOverrideMutation,
+  setPrimaryWebDomainMutation: () => setPrimaryWebDomainMutation,
+  setSettingMutation: () => setSettingMutation,
+  setWebThemeEnabledMutation: () => setWebThemeEnabledMutation,
+  settingSchema: () => settingSchema,
+  settingSchemaSchema: () => settingSchemaSchema,
+  settingSchemas: () => settingSchemas,
+  settingScopeSchema: () => settingScopeSchema,
+  settingValueTypeSchema: () => settingValueTypeSchema,
+  settings: () => settings,
+  subdivisionFullCodeSchema: () => subdivisionFullCodeSchema,
+  taskExecutionSchema: () => taskExecutionSchema,
+  taskExecutions: () => taskExecutions,
+  team: () => team,
+  teamMember: () => teamMember,
+  teamMemberSchema: () => teamMemberSchema,
+  teamSchema: () => teamSchema,
+  tenantQuotaSchema: () => tenantQuotaSchema,
+  tenantQuotas: () => tenantQuotas,
+  toggleMenuVisibilityMutation: () => toggleMenuVisibilityMutation,
+  transactionSchema: () => transactionSchema,
+  transactions: () => transactions,
+  translationsObjectSchema: () => translationsObjectSchema,
+  uninstallPluginFromInstanceMutation: () => uninstallPluginFromInstanceMutation,
+  updateFeatureFlagMutation: () => updateFeatureFlagMutation,
+  updateMenuMutation: () => updateMenuMutation,
+  updateMenuSchema: () => updateMenuSchema,
+  updateProfileMutation: () => updateProfileMutation,
+  updateWebDomainCertificateStatusMutation: () => updateWebDomainCertificateStatusMutation,
+  updateWebPageMutation: () => updateWebPageMutation,
+  usageRecordSchema: () => usageRecordSchema,
+  usageRecords: () => usageRecords,
+  user: () => user,
+  userQuotaSchema: () => userQuotaSchema,
+  userQuotas: () => userQuotas,
+  userSchema: () => userSchema,
+  verification: () => verification,
+  verificationSchema: () => verificationSchema,
+  verifyWebDomainMutation: () => verifyWebDomainMutation,
+  walletSchema: () => walletSchema,
+  wallets: () => wallets,
+  webDesignDocumentSchema: () => webDesignDocumentSchema,
+  webDomainHostnameSchema: () => webDomainHostnameSchema,
+  webDomainSchema: () => webDomainSchema,
+  webDomainSelectSchema: () => webDomainSelectSchema,
+  webDomains: () => webDomains,
+  webPagePathSchema: () => webPagePathSchema,
+  webPageSchema: () => webPageSchema,
+  webPageSelectSchema: () => webPageSelectSchema,
+  webPages: () => webPages,
+  webThemeAdapterConfigSchema: () => webThemeAdapterConfigSchema,
+  webThemeAdapterSelectionSchema: () => webThemeAdapterSelectionSchema,
+  webThemeHomeTargetSchema: () => webThemeHomeTargetSchema,
+  webThemeRevisionSchema: () => webThemeRevisionSchema,
+  webThemeRevisionSelectSchema: () => webThemeRevisionSelectSchema,
+  webThemeRevisions: () => webThemeRevisions,
+  webThemeSelectionSchema: () => webThemeSelectionSchema,
+  webThemeSelectionSelectSchema: () => webThemeSelectionSelectSchema,
+  webThemeSelections: () => webThemeSelections,
+  webhookDeliveries: () => webhookDeliveries,
+  webhookDeliverySchema: () => webhookDeliverySchema,
+  webhookEndpointSchema: () => webhookEndpointSchema,
+  webhookEndpoints: () => webhookEndpoints,
+  webhookOutbox: () => webhookOutbox,
+  webhookOutboxSchema: () => webhookOutboxSchema
+});
+
+// src/schema/auth.ts
+import {
+  pgTable,
+  text,
+  integer,
+  timestamp,
+  boolean,
+  index,
+  uniqueIndex
+} from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-orm/zod";
+import { z } from "zod";
+var user = pgTable("user", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  email: text("email").notNull().unique(),
+  emailVerified: boolean("email_verified").default(false).notNull(),
+  image: text("image"),
+  phoneNumber: text("phone_number").unique(),
+  phoneNumberVerified: boolean("phone_number_verified").default(false).notNull(),
+  whatsappAccount: text("whatsapp_account"),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull(),
+  // Admin plugin fields
+  role: text("role").default("user"),
+  banned: boolean("banned").default(false),
+  banReason: text("ban_reason"),
+  banExpires: timestamp("ban_expires")
+});
+var session = pgTable(
+  "session",
+  {
+    id: text("id").primaryKey(),
+    expiresAt: timestamp("expires_at").notNull(),
+    token: text("token").notNull().unique(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull(),
+    ipAddress: text("ip_address"),
+    userAgent: text("user_agent"),
+    // FK to user table
+    userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+    activeOrganizationId: text("active_organization_id"),
+    // Admin plugin field for impersonation
+    impersonatedBy: text("impersonated_by")
+  },
+  (table) => [index("session_userId_idx").on(table.userId)]
+);
+var CREDENTIAL_ACCOUNT_ISSUER = "local:credential";
+var account = pgTable(
+  "account",
+  {
+    id: text("id").primaryKey(),
+    accountId: text("account_id").notNull(),
+    providerId: text("provider_id").notNull(),
+    issuer: text("issuer").notNull(),
+    // FK to user table
+    userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+    accessToken: text("access_token"),
+    refreshToken: text("refresh_token"),
+    idToken: text("id_token"),
+    accessTokenExpiresAt: timestamp("access_token_expires_at"),
+    refreshTokenExpiresAt: timestamp("refresh_token_expires_at"),
+    scope: text("scope"),
+    password: text("password"),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull()
+  },
+  (table) => [
+    index("account_userId_idx").on(table.userId),
+    uniqueIndex("account_issuer_accountId_uidx").on(table.issuer, table.accountId)
+  ]
+);
+var verification = pgTable(
+  "verification",
+  {
+    id: text("id").primaryKey(),
+    identifier: text("identifier").notNull(),
+    value: text("value").notNull(),
+    expiresAt: timestamp("expires_at").notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull()
+  },
+  (table) => [index("verification_identifier_idx").on(table.identifier)]
+);
+var organization = pgTable(
+  "organization",
+  {
+    id: text("id").primaryKey(),
+    name: text("name").notNull(),
+    slug: text("slug").notNull().unique(),
+    logo: text("logo"),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    metadata: text("metadata")
+  },
+  (table) => [uniqueIndex("organization_slug_uidx").on(table.slug)]
+);
+var member = pgTable(
+  "member",
+  {
+    id: text("id").primaryKey(),
+    // FK to organization table
+    organizationId: text("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    // FK to user table
+    userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+    role: text("role").default("member").notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    // Tenant-level ban fields
+    status: text("status").default("active").notNull(),
+    banReason: text("ban_reason"),
+    banExpires: timestamp("ban_expires")
+  },
+  (table) => [
+    index("member_organizationId_idx").on(table.organizationId),
+    index("member_userId_idx").on(table.userId)
+  ]
+);
+var invitation = pgTable(
+  "invitation",
+  {
+    id: text("id").primaryKey(),
+    // FK to organization table
+    organizationId: text("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    email: text("email").notNull(),
+    role: text("role"),
+    status: text("status").default("pending").notNull(),
+    expiresAt: timestamp("expires_at").notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    // FK to user table
+    inviterId: text("inviter_id").notNull().references(() => user.id, { onDelete: "cascade" })
+  },
+  (table) => [
+    index("invitation_organizationId_idx").on(table.organizationId),
+    index("invitation_email_idx").on(table.email)
+  ]
+);
+var apikey = pgTable(
+  "apikey",
+  {
+    id: text("id").primaryKey(),
+    configId: text("config_id").default("default").notNull(),
+    name: text("name"),
+    start: text("start"),
+    prefix: text("prefix"),
+    key: text("key").notNull(),
+    // FK to user table
+    referenceId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+    refillInterval: integer("refill_interval"),
+    refillAmount: integer("refill_amount"),
+    lastRefillAt: timestamp("last_refill_at"),
+    enabled: boolean("enabled").default(true),
+    rateLimitEnabled: boolean("rate_limit_enabled").default(true),
+    rateLimitTimeWindow: integer("rate_limit_time_window"),
+    rateLimitMax: integer("rate_limit_max"),
+    requestCount: integer("request_count").default(0),
+    remaining: integer("remaining"),
+    lastRequest: timestamp("last_request"),
+    expiresAt: timestamp("expires_at"),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull(),
+    permissions: text("permissions"),
+    metadata: text("metadata")
+  },
+  (table) => [
+    index("apikey_configId_idx").on(table.configId),
+    index("apikey_userId_idx").on(table.referenceId)
+  ]
+);
+var userSchema = createInsertSchema(user);
+var sessionSchema = createInsertSchema(session);
+var accountSchema = createInsertSchema(account);
+var verificationSchema = createInsertSchema(verification);
+var organizationSchema = createInsertSchema(organization);
+var memberSchema = createInsertSchema(member);
+var invitationSchema = createInsertSchema(invitation);
+var apikeySchema = createInsertSchema(apikey);
+var updateProfileMutation = z.object({
+  name: z.preprocess(
+    (value) => typeof value === "string" ? value.trim() : value,
+    z.string().min(1, "\u59D3\u540D\u4E0D\u80FD\u4E3A\u7A7A").max(80, "\u59D3\u540D\u4E0D\u80FD\u8D85\u8FC7 80 \u4E2A\u5B57\u7B26").optional()
+  ),
+  whatsappAccount: z.preprocess(
+    (value) => typeof value === "string" ? value.trim() : value,
+    z.string().max(64).nullable().optional()
+  ).transform((value) => value === "" ? null : value)
+});
+
+// src/schema/teams.ts
+import {
+  pgTable as pgTable2,
+  text as text2,
+  timestamp as timestamp2,
+  integer as integer2,
+  index as index2,
+  uniqueIndex as uniqueIndex2
+} from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema2 } from "drizzle-orm/zod";
+var team = pgTable2(
+  "team",
+  {
+    id: text2("id").primaryKey(),
+    name: text2("name").notNull(),
+    // FK to organization table
+    organizationId: text2("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    createdAt: timestamp2("created_at").defaultNow().notNull(),
+    updatedAt: timestamp2("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull(),
+    // Hierarchical structure
+    parentId: text2("parent_id"),
+    path: text2("path"),
+    // Materialized path for efficient tree queries
+    level: integer2("level").default(0).notNull()
+  },
+  (table) => [
+    index2("team_organizationId_idx").on(table.organizationId),
+    index2("team_parent_idx").on(table.parentId),
+    index2("team_org_path_idx").on(table.organizationId, table.path)
+  ]
+);
+var teamMember = pgTable2(
+  "team_member",
+  {
+    id: text2("id").primaryKey(),
+    // FK to team table
+    teamId: text2("team_id").notNull().references(() => team.id, { onDelete: "cascade" }),
+    // FK to user table
+    userId: text2("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+    createdAt: timestamp2("created_at").defaultNow().notNull()
+  },
+  (table) => [
+    uniqueIndex2("teamMember_team_user_uidx").on(table.teamId, table.userId),
+    index2("teamMember_teamId_idx").on(table.teamId),
+    index2("teamMember_userId_idx").on(table.userId)
+  ]
+);
+var teamSchema = createInsertSchema2(team);
+var teamMemberSchema = createInsertSchema2(teamMember);
+
+// src/schema/relationships.ts
+import {
+  pgTable as pgTable3,
+  text as text3,
+  timestamp as timestamp3,
+  jsonb,
+  index as index3,
+  uniqueIndex as uniqueIndex3
+} from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema3 } from "drizzle-orm/zod";
+var relationship = pgTable3(
+  "relationship",
+  {
+    id: text3("id").primaryKey(),
+    // Relationship type (e.g., 'follows', 'contains', 'manages')
+    type: text3("type").notNull(),
+    // Source entity ID
+    sourceId: text3("source_id").notNull(),
+    // Target entity ID
+    targetId: text3("target_id").notNull(),
+    // FK to organization table
+    organizationId: text3("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    // Additional metadata for the relationship
+    metadata: jsonb("metadata"),
+    createdAt: timestamp3("created_at").defaultNow().notNull()
+  },
+  (table) => [
+    index3("relationship_org_idx").on(table.organizationId),
+    index3("relationship_source_idx").on(table.type, table.sourceId),
+    index3("relationship_target_idx").on(table.type, table.targetId),
+    uniqueIndex3("relationship_unique_idx").on(
+      table.type,
+      table.sourceId,
+      table.targetId
+    )
+  ]
+);
+var relationshipSchema = createInsertSchema3(relationship);
+
+// src/schema/i18n.ts
+import {
+  pgTable as pgTable4,
+  text as text4,
+  timestamp as timestamp4,
+  boolean as boolean2,
+  integer as integer3,
+  jsonb as jsonb2,
+  varchar,
+  index as index4,
+  uniqueIndex as uniqueIndex4
+} from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema4 } from "drizzle-orm/zod";
+import { z as z3 } from "zod/v4";
+
+// src/schema/common.ts
+import { z as z2 } from "zod/v4";
+var paginationSchema = z2.object({
+  limit: z2.number().int().min(1).max(100).default(20),
+  offset: z2.number().int().min(0).default(0)
+});
+var cursorPaginationSchema = z2.object({
+  cursor: z2.string().optional(),
+  limit: z2.number().int().min(1).max(100).default(20)
+});
+var sortSchema = z2.object({
+  sortBy: z2.string().optional(),
+  sortOrder: z2.enum(["asc", "desc"]).default("asc")
+});
+var searchSchema = z2.object({
+  q: z2.string().min(1).optional()
+});
+var listQueryBase = paginationSchema.merge(sortSchema);
+var searchListQueryBase = listQueryBase.merge(searchSchema);
+var idSchema = z2.object({
+  id: z2.string()
+});
+var uuidSchema = z2.object({
+  id: z2.string().uuid()
+});
+var batchIdsSchema = z2.object({
+  ids: z2.array(z2.string()).min(1)
+});
+var dateRangeSchema = z2.object({
+  startDate: z2.string().datetime().optional(),
+  endDate: z2.string().datetime().optional()
+});
+
+// src/schema/i18n.ts
+var I18N_MESSAGE_FORMATS = [
+  "legacy-mixed",
+  "i18next-v4",
+  "legacy-projection"
+];
+var i18nLanguages = pgTable4(
+  "i18n_languages",
+  {
+    id: text4("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // FK to organization table
+    organizationId: text4("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    // Language identification (BCP 47)
+    locale: text4("locale").notNull(),
+    // e.g., 'en-US', 'zh-CN', 'ar-SA'
+    name: text4("name").notNull(),
+    // e.g., 'English', '简体中文', 'العربية'
+    nativeName: text4("native_name"),
+    // e.g., 'English', '中文', 'العربية'
+    // Status
+    isDefault: boolean2("is_default").notNull().default(false),
+    isEnabled: boolean2("is_enabled").notNull().default(true),
+    // Display order
+    sortOrder: integer3("sort_order").notNull().default(0),
+    // RTL support
+    direction: text4("direction").notNull().default("ltr").$type(),
+    // Audit fields
+    createdAt: timestamp4("created_at").notNull().defaultNow(),
+    updatedAt: timestamp4("updated_at").notNull().defaultNow().$onUpdate(() => /* @__PURE__ */ new Date())
+  },
+  (table) => [
+    // Each locale is unique per organization
+    uniqueIndex4("i18n_languages_org_locale_uidx").on(
+      table.organizationId,
+      table.locale
+    ),
+    // Fast lookup by organization
+    index4("i18n_languages_org_idx").on(table.organizationId),
+    // Fast lookup for enabled languages
+    index4("i18n_languages_enabled_idx").on(table.organizationId, table.isEnabled)
+  ]
+);
+var i18nMessages = pgTable4(
+  "i18n_messages",
+  {
+    id: text4("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // FK to organization table
+    organizationId: text4("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    // Message identification
+    key: text4("key").notNull(),
+    // e.g., 'order.submit', 'common.save'
+    namespace: text4("namespace").notNull(),
+    // e.g., 'core', 'admin', 'plugin:dsneo.orders'
+    // Message type
+    type: text4("type").notNull().default("page").$type(),
+    // Translations (JSONB)
+    translations: jsonb2("translations").notNull().default({}).$type(),
+    // Description for translators
+    description: text4("description"),
+    // Source tracking
+    source: text4("source").notNull().default("user").$type(),
+    sourceId: text4("source_id"),
+    // Plugin ID if source is 'plugin'
+    // User modification tracking (for plugin upgrade protection)
+    // Deprecated rollback-only mirror. New runtime code must not read or write it.
+    userModified: boolean2("user_modified").notNull().default(false),
+    modifiedLocales: jsonb2("modified_locales").notNull().default([]).$type(),
+    archivedLocales: jsonb2("archived_locales").notNull().default([]).$type(),
+    messageFormat: varchar("message_format", {
+      length: 32,
+      enum: I18N_MESSAGE_FORMATS
+    }).notNull().default("i18next-v4").$type(),
+    // Status
+    isEnabled: boolean2("is_enabled").notNull().default(true),
+    // Version for optimistic locking
+    version: integer3("version").notNull().default(1),
+    // Audit fields
+    createdAt: timestamp4("created_at").notNull().defaultNow(),
+    updatedAt: timestamp4("updated_at").notNull().defaultNow().$onUpdate(() => /* @__PURE__ */ new Date())
+  },
+  (table) => [
+    // Each key is unique per organization + namespace
+    uniqueIndex4("i18n_messages_org_ns_key_uidx").on(
+      table.organizationId,
+      table.namespace,
+      table.key
+    ),
+    // Fast lookup by organization
+    index4("i18n_messages_org_idx").on(table.organizationId),
+    // Fast lookup by namespace (for loading translations)
+    index4("i18n_messages_org_ns_idx").on(table.organizationId, table.namespace),
+    // Fast lookup by source (for plugin lifecycle)
+    index4("i18n_messages_source_idx").on(table.source, table.sourceId)
+  ]
+);
+var i18nBundleVersions = pgTable4(
+  "i18n_bundle_versions",
+  {
+    id: text4("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    organizationId: text4("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    namespace: text4("namespace").notNull(),
+    generation: integer3("generation").notNull().default(1),
+    cacheDirty: boolean2("cache_dirty").notNull().default(false),
+    createdAt: timestamp4("created_at").notNull().defaultNow(),
+    updatedAt: timestamp4("updated_at").notNull().defaultNow().$onUpdate(() => /* @__PURE__ */ new Date())
+  },
+  (table) => [
+    uniqueIndex4("i18n_bundle_versions_org_ns_uidx").on(
+      table.organizationId,
+      table.namespace
+    ),
+    index4("i18n_bundle_versions_dirty_idx").on(
+      table.cacheDirty,
+      table.organizationId
+    )
+  ]
+);
+function canonicalizeLocale(value) {
+  if (typeof value !== "string") return void 0;
+  const locale = value.trim();
+  if (!locale || locale === "*") return void 0;
+  try {
+    return Intl.getCanonicalLocales(locale)[0];
+  } catch {
+    return void 0;
+  }
+}
+var localeSchema = z3.string().min(1).refine((value) => canonicalizeLocale(value) !== void 0, "Invalid BCP 47 locale").transform((value) => canonicalizeLocale(value));
+var translationsObjectSchema = z3.record(z3.string(), z3.string());
+var i18nDirectionSchema = z3.enum(["ltr", "rtl"]);
+var i18nMessageTypeSchema = z3.enum(["page", "api"]);
+var i18nMessageSourceSchema = z3.enum(["core", "plugin", "user"]);
+var i18nMessageFormatSchema = z3.enum(I18N_MESSAGE_FORMATS);
+var i18nLanguageSchema = createInsertSchema4(i18nLanguages, {
+  locale: () => localeSchema,
+  name: (schema) => schema.min(1).max(50),
+  nativeName: (schema) => schema.max(50)
+});
+var i18nMessageSchema = createInsertSchema4(i18nMessages, {
+  key: (schema) => schema.min(1).max(200),
+  namespace: (schema) => schema.min(1).max(100)
+});
+var getI18nMessagesQuery = z3.object({
+  locale: localeSchema,
+  namespaces: z3.array(z3.string()).optional(),
+  version: z3.string().optional()
+});
+var getI18nBundlesQuery = z3.object({
+  locale: localeSchema,
+  namespaces: z3.array(z3.string().min(1).max(160)).min(1).max(32),
+  versions: z3.record(z3.string(), z3.string()).optional()
+});
+var i18nBundleSchema = z3.object({
+  version: z3.string(),
+  notModified: z3.boolean(),
+  messages: translationsObjectSchema.optional()
+});
+var getI18nBundlesResultSchema = z3.object({
+  bundles: z3.record(z3.string(), i18nBundleSchema)
+});
+var listI18nLanguagesQuery = paginationSchema.partial();
+var listI18nMessagesQuery = z3.object({
+  namespace: z3.string().optional(),
+  key: z3.string().optional()
+}).merge(paginationSchema.partial());
+var setDefaultLanguageMutation = z3.object({
+  locale: localeSchema
+});
+var batchUpdateMessagesMutation = z3.object({
+  messages: z3.array(z3.object({
+    key: z3.string(),
+    namespace: z3.string(),
+    translations: translationsObjectSchema
+  }))
+});
+
+// src/schema/roles.ts
+import {
+  pgTable as pgTable5,
+  text as text5,
+  timestamp as timestamp5,
+  boolean as boolean3,
+  uniqueIndex as uniqueIndex5,
+  index as index5
+} from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema5 } from "drizzle-orm/zod";
+var roles = pgTable5(
+  "roles",
+  {
+    id: text5("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // FK to organization table
+    organizationId: text5("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    name: text5("name").notNull(),
+    slug: text5("slug").notNull(),
+    description: text5("description"),
+    isSystem: boolean3("is_system").notNull().default(false),
+    createdAt: timestamp5("created_at").notNull().defaultNow(),
+    updatedAt: timestamp5("updated_at").notNull().defaultNow().$onUpdate(() => /* @__PURE__ */ new Date())
+  },
+  (table) => [
+    uniqueIndex5("roles_org_slug_uidx").on(table.organizationId, table.slug),
+    index5("roles_organization_id_idx").on(table.organizationId)
+  ]
+);
+var roleSchema = createInsertSchema5(roles);
+
+// src/schema/role-permissions.ts
+import {
+  pgTable as pgTable6,
+  text as text6,
+  timestamp as timestamp6,
+  boolean as boolean4,
+  jsonb as jsonb3,
+  uniqueIndex as uniqueIndex6,
+  index as index6
+} from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema6 } from "drizzle-orm/zod";
+var rolePermissions = pgTable6(
+  "role_permissions",
+  {
+    id: text6("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // FK to roles table
+    roleId: text6("role_id").notNull().references(() => roles.id, { onDelete: "cascade" }),
+    // CASL rule fields
+    action: text6("action").notNull(),
+    subject: text6("subject").notNull(),
+    fields: jsonb3("fields").$type(),
+    conditions: jsonb3("conditions").$type(),
+    inverted: boolean4("inverted").notNull().default(false),
+    // Plugin tracking
+    source: text6("source"),
+    // Plugin ID if from a plugin, null for core permissions
+    createdAt: timestamp6("created_at").notNull().defaultNow()
+  },
+  (table) => [
+    // Unique constraint on role + action + subject combination
+    uniqueIndex6("role_permissions_role_action_subject_uidx").on(
+      table.roleId,
+      table.action,
+      table.subject
+    ),
+    index6("role_permissions_role_id_idx").on(table.roleId),
+    index6("role_permissions_source_idx").on(table.source)
+  ]
+);
+var rolePermissionSchema = createInsertSchema6(rolePermissions);
+
+// src/schema/permissions.ts
+import { pgTable as pgTable7, text as text7, timestamp as timestamp7 } from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema7 } from "drizzle-orm/zod";
+var permissions = pgTable7("permissions", {
+  id: text7("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+  capability: text7("capability").notNull().unique(),
+  source: text7("source").notNull(),
+  // 'core' | pluginId
+  description: text7("description"),
+  createdAt: timestamp7("created_at").notNull().defaultNow()
+});
+var permissionSchema = createInsertSchema7(permissions);
+var ROLE_PERMISSIONS = {
+  owner: ["*:*:*"],
+  admin: ["organization:*:*", "plugin:*:*", "user:manage:*", "content:*:*"],
+  editor: ["content:create:space", "content:update:own", "content:read:*"],
+  member: ["content:read:space", "content:comment:*"],
+  viewer: ["content:read:public"]
+};
+
+// src/schema/menus.ts
+import {
+  pgTable as pgTable8,
+  text as text8,
+  integer as integer4,
+  timestamp as timestamp8,
+  jsonb as jsonb4,
+  index as index7,
+  uniqueIndex as uniqueIndex7,
+  boolean as boolean5
+} from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema8 } from "drizzle-orm/zod";
+import { z as z4 } from "zod/v4";
+var menus = pgTable8(
+  "menus",
+  {
+    // Primary key (UUID for database)
+    id: text8("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // Logical identifier (stable across tenants)
+    // Format: 'core:dashboard', 'plugin:blog:posts', 'custom:my-menu'
+    code: text8("code").notNull(),
+    // Menu Type
+    type: text8("type").notNull().$type(),
+    // system = core/plugin, custom = tenant-created
+    // Source (for system menus: 'core' | pluginId)
+    source: text8("source").notNull(),
+    // 'core' | pluginId | 'custom'
+    // FK to organization table (nullable: NULL = global template, value = organization-specific)
+    organizationId: text8("organization_id").references(() => organization.id, { onDelete: "cascade" }),
+    // Menu Display
+    label: text8("label").notNull(),
+    icon: text8("icon"),
+    path: text8("path"),
+    // NULL for directory menus
+    openMode: text8("open_mode").notNull().default("route").$type(),
+    // Hierarchy (using code for logical reference)
+    parentCode: text8("parent_code"),
+    // NULL = root level, 'SYS_INBOX' = orphaned
+    order: integer4("order").notNull().default(0),
+    // Visibility Control
+    visible: boolean5("visible").notNull().default(true),
+    // Tenant can hide menus
+    // Permission Control
+    requiredPermission: text8("required_permission"),
+    // Target Application
+    target: text8("target").notNull().$type(),
+    // Extensibility
+    metadata: jsonb4("metadata"),
+    // Timestamps
+    createdAt: timestamp8("created_at").notNull().defaultNow(),
+    updatedAt: timestamp8("updated_at").notNull().defaultNow()
+  },
+  (table) => [
+    // Unique constraint: code + organizationId (allows same code in different organizations)
+    uniqueIndex7("menus_code_org_idx").on(table.code, table.organizationId),
+    // Query optimization indexes
+    index7("menus_org_idx").on(table.organizationId),
+    index7("menus_source_org_idx").on(table.source, table.organizationId),
+    index7("menus_target_idx").on(table.target),
+    index7("menus_parent_code_idx").on(table.parentCode),
+    index7("menus_type_idx").on(table.type)
+  ]
+);
+var SYS_INBOX_CODE = "SYS_INBOX";
+var menuSchema = createInsertSchema8(menus);
+var getMenuQuery = z4.object({
+  code: z4.string()
+});
+var listMenusQuery = z4.object({
+  target: z4.enum(["admin", "web"])
+});
+var listAllMenusQuery = z4.object({
+  target: z4.enum(["admin", "web"]).optional()
+}).merge(paginationSchema.partial());
+var deleteMenuMutation = z4.object({
+  code: z4.string()
+});
+var toggleMenuVisibilityMutation = z4.object({
+  code: z4.string(),
+  visible: z4.boolean()
+});
+var createMenuSchema = menuSchema.pick({
+  code: true,
+  label: true,
+  path: true,
+  icon: true,
+  openMode: true,
+  parentCode: true,
+  order: true,
+  target: true,
+  metadata: true
+}).extend({
+  openMode: z4.enum(["route", "external"]).optional(),
+  target: z4.enum(["admin", "web"])
+});
+var updateMenuSchema = menuSchema.pick({
+  label: true,
+  icon: true,
+  path: true,
+  openMode: true,
+  parentCode: true,
+  order: true,
+  visible: true,
+  metadata: true
+}).partial().extend({
+  openMode: z4.enum(["route", "external"]).optional()
+});
+var updateMenuMutation = menuSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true
+}).partial().extend({
+  code: z4.string()
+  // Required for identification
+});
+
+// src/schema/plugins.ts
+import {
+  index as index8,
+  pgTable as pgTable9,
+  text as text9,
+  timestamp as timestamp9,
+  jsonb as jsonb5,
+  uniqueIndex as uniqueIndex8,
+  varchar as varchar2
+} from "drizzle-orm/pg-core";
+import { sql } from "drizzle-orm";
+import { createInsertSchema as createInsertSchema9 } from "drizzle-orm/zod";
+import { z as z5 } from "zod";
+var PLUGIN_MARKETPLACE_STATES = [
+  "draft",
+  "published",
+  "archived",
+  "suspended",
+  "removed"
+];
+var PLUGIN_TRUST_LEVELS = ["first_party", "third_party"];
+var PLUGIN_INSTALL_OPERATIONS = ["install", "update", "uninstall", "rollback"];
+var PLUGIN_INSTALL_SOURCES = ["registry", "upload", "system"];
+var PLUGIN_INSTALL_JOB_STATUSES = [
+  "queued",
+  "validating",
+  "staging",
+  "awaiting_reload",
+  "succeeded",
+  "failed",
+  "rolled_back"
+];
+var plugins = pgTable9(
+  "plugins",
+  {
+    id: text9("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    pluginId: text9("plugin_id").notNull(),
+    // FK to organization table
+    organizationId: text9("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    version: text9("version").notNull(),
+    installationStatus: text9("installation_status").notNull().$type().default("installed"),
+    activationStatus: text9("activation_status").notNull().$type().default("enabled"),
+    status: text9("status").notNull().$type(),
+    manifest: jsonb5("manifest").notNull().$type(),
+    installedAt: timestamp9("installed_at").notNull().defaultNow(),
+    updatedAt: timestamp9("updated_at").notNull().defaultNow(),
+    scheduledDeletionAt: timestamp9("scheduled_deletion_at")
+  },
+  (table) => [
+    uniqueIndex8("unique_plugin_per_org").on(table.organizationId, table.pluginId),
+    index8("plugins_plugin_installation_idx").on(
+      table.pluginId,
+      table.installationStatus,
+      table.organizationId
+    )
+  ]
+);
+var pluginInstances = pgTable9(
+  "plugin_instances",
+  {
+    id: text9("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    pluginId: text9("plugin_id").notNull(),
+    version: text9("version").notNull(),
+    status: text9("status").notNull().$type(),
+    manifest: jsonb5("manifest").notNull().$type(),
+    installedAt: timestamp9("installed_at").notNull().defaultNow(),
+    updatedAt: timestamp9("updated_at").notNull().defaultNow()
+  },
+  (table) => [
+    uniqueIndex8("unique_plugin_per_instance").on(table.pluginId)
+  ]
+);
+var pluginCatalogReleases = pgTable9(
+  "plugin_catalog_releases",
+  {
+    id: text9("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    sourceId: text9("source_id").notNull(),
+    pluginId: varchar2("plugin_id", { length: 160 }).notNull(),
+    version: varchar2("version", { length: 80 }).notNull(),
+    state: varchar2("state", { length: 20, enum: PLUGIN_MARKETPLACE_STATES }).notNull().$type(),
+    trustLevel: varchar2("trust_level", { length: 20, enum: PLUGIN_TRUST_LEVELS }).notNull().$type(),
+    manifest: jsonb5("manifest").notNull().$type(),
+    release: jsonb5("release").notNull().$type(),
+    artifactUrl: text9("artifact_url").notNull(),
+    artifactSha256: varchar2("artifact_sha256", { length: 64 }).notNull(),
+    publisherId: varchar2("publisher_id", { length: 160 }),
+    releaseSha256: varchar2("release_sha256", { length: 64 }),
+    publisherSignature: jsonb5("publisher_signature").$type(),
+    registrySignature: jsonb5("registry_signature").$type(),
+    /** @deprecated Legacy alias for publisherSignature. */
+    signature: jsonb5("signature").$type(),
+    publishedAt: timestamp9("published_at").notNull(),
+    fetchedAt: timestamp9("fetched_at").notNull().defaultNow()
+  },
+  (table) => [
+    uniqueIndex8("plugin_catalog_release_unique").on(table.sourceId, table.pluginId, table.version),
+    index8("plugin_catalog_release_lookup_idx").on(table.pluginId, table.state, table.publishedAt)
+  ]
+);
+var pluginRegistrySyncState = pgTable9("plugin_registry_sync_state", {
+  sourceId: text9("source_id").primaryKey(),
+  snapshotId: varchar2("snapshot_id", { length: 160 }).notNull(),
+  generatedAt: timestamp9("generated_at").notNull(),
+  fetchedAt: timestamp9("fetched_at").notNull().defaultNow()
+});
+var pluginInstallJobs = pgTable9(
+  "plugin_install_jobs",
+  {
+    id: text9("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    pluginId: varchar2("plugin_id", { length: 160 }).notNull(),
+    operation: varchar2("operation", { length: 20, enum: PLUGIN_INSTALL_OPERATIONS }).notNull().$type(),
+    source: varchar2("source", { length: 20, enum: PLUGIN_INSTALL_SOURCES }).notNull().$type(),
+    sourceId: text9("source_id"),
+    releaseId: text9("release_id").references(() => pluginCatalogReleases.id, { onDelete: "set null" }),
+    previousVersion: varchar2("previous_version", { length: 80 }),
+    targetVersion: varchar2("target_version", { length: 80 }),
+    status: varchar2("status", { length: 24, enum: PLUGIN_INSTALL_JOB_STATUSES }).notNull().$type().default("queued"),
+    artifactSha256: varchar2("artifact_sha256", { length: 64 }),
+    requestedBy: text9("requested_by").notNull(),
+    errorCode: varchar2("error_code", { length: 80 }),
+    errorMessage: text9("error_message"),
+    metadata: jsonb5("metadata").notNull().$type().default({}),
+    createdAt: timestamp9("created_at").notNull().defaultNow(),
+    updatedAt: timestamp9("updated_at").notNull().defaultNow(),
+    completedAt: timestamp9("completed_at")
+  },
+  (table) => [
+    uniqueIndex8("plugin_install_jobs_active_plugin_uidx").on(table.pluginId).where(sql`${table.status} IN ('queued', 'validating', 'staging', 'awaiting_reload')`),
+    index8("plugin_install_jobs_plugin_idx").on(table.pluginId, table.createdAt),
+    index8("plugin_install_jobs_status_idx").on(table.status, table.createdAt)
+  ]
+);
+var pluginConfigs = pgTable9(
+  "plugin_configs",
+  {
+    id: text9("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    pluginId: text9("plugin_id").notNull(),
+    // FK to organization table
+    organizationId: text9("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    key: text9("key").notNull(),
+    value: jsonb5("value").notNull(),
+    updatedAt: timestamp9("updated_at").notNull().defaultNow()
+  },
+  (table) => [
+    uniqueIndex8("unique_config_key").on(
+      table.organizationId,
+      table.pluginId,
+      table.key
+    )
+  ]
+);
+var pluginSchema = createInsertSchema9(plugins);
+var pluginInstanceSchema = createInsertSchema9(pluginInstances);
+var pluginCatalogReleaseSchema = createInsertSchema9(pluginCatalogReleases, {
+  artifactUrl: () => z5.url(),
+  artifactSha256: () => z5.string().regex(/^[a-f0-9]{64}$/)
+});
+var pluginInstallJobSchema = createInsertSchema9(pluginInstallJobs);
+var pluginConfigSchema = createInsertSchema9(pluginConfigs);
+var listPluginCatalogQuery = z5.object({
+  query: z5.string().trim().min(1).max(120).optional(),
+  limit: z5.number().int().min(1).max(100).default(20),
+  offset: z5.number().int().nonnegative().default(0)
+});
+var installPluginFromRegistryMutation = z5.object({
+  pluginId: z5.string().regex(/^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)+$/),
+  version: z5.string().min(1).max(80)
+});
+var createPluginUploadMutation = z5.object({
+  pluginId: z5.string().regex(/^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)+$/),
+  version: z5.string().min(1).max(80),
+  totalSize: z5.number().int().positive().max(100 * 1024 * 1024),
+  sha256: z5.string().regex(/^[a-f0-9]{64}$/)
+});
+var appendPluginUploadMutation = z5.object({
+  uploadId: z5.string().uuid(),
+  offset: z5.number().int().nonnegative(),
+  chunkBase64: z5.base64().min(1).max(1024 * 1024)
+});
+var completePluginUploadMutation = z5.object({
+  uploadId: z5.string().uuid()
+});
+var getPluginInstallJobQuery = pluginInstallJobSchema.pick({ id: true }).required();
+var uninstallPluginFromInstanceMutation = z5.object({
+  pluginId: z5.string().regex(/^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)+$/),
+  retentionChoice: z5.enum(["retain", "archive", "delete"]).optional(),
+  confirmed: z5.boolean().optional()
+});
+var rollbackPluginInstallMutation = getPluginInstallJobQuery;
+
+// src/schema/plugin-migrations.ts
+import { pgTable as pgTable10, text as text10, timestamp as timestamp10, uniqueIndex as uniqueIndex9 } from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema10 } from "drizzle-orm/zod";
+var pluginMigrations = pgTable10(
+  "plugin_migrations",
+  {
+    id: text10("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    pluginId: text10("plugin_id").notNull(),
+    // FK to organization table
+    organizationId: text10("organization_id").notNull(),
+    migrationFile: text10("migration_file").notNull(),
+    appliedAt: timestamp10("applied_at").notNull().defaultNow(),
+    checksum: text10("checksum").notNull()
+    // SHA256 of file content
+  },
+  (table) => [
+    uniqueIndex9("unique_plugin_migration").on(
+      table.organizationId,
+      table.pluginId,
+      table.migrationFile
+    )
+  ]
+);
+var pluginMigrationSchema = createInsertSchema10(pluginMigrations);
+
+// src/schema/entity-extensions.ts
+import {
+  boolean as boolean7,
+  index as index9,
+  jsonb as jsonb6,
+  numeric,
+  pgTable as pgTable11,
+  text as text11,
+  timestamp as timestamp11,
+  uniqueIndex as uniqueIndex10,
+  varchar as varchar3
+} from "drizzle-orm/pg-core";
+var ENTITY_EXTENSION_VALUE_TYPES = [
+  "text",
+  "number",
+  "boolean",
+  "date",
+  "datetime",
+  "select",
+  "ref",
+  "json"
+];
+var ENTITY_EXTENSION_PROJECTION_STATUSES = [
+  "active",
+  "stale",
+  "deleted"
+];
+var extProjection = pgTable11(
+  "ext_projection",
+  {
+    id: text11("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    organizationId: text11("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    pluginId: text11("plugin_id").notNull(),
+    entity: varchar3("entity", { length: 160 }).notNull(),
+    entityId: text11("entity_id").notNull(),
+    field: varchar3("field", { length: 80 }).notNull(),
+    type: varchar3("type", { length: 30 }).notNull().$type(),
+    valueText: text11("value_text"),
+    valueNumber: numeric("value_number"),
+    valueBoolean: boolean7("value_boolean"),
+    valueDate: timestamp11("value_date", { withTimezone: true }),
+    valueJson: jsonb6("value_json").$type(),
+    refEntity: varchar3("ref_entity", { length: 160 }),
+    refId: text11("ref_id"),
+    display: text11("display"),
+    search: text11("search"),
+    status: varchar3("status", { length: 20 }).notNull().$type().default("active"),
+    syncedAt: timestamp11("synced_at", { withTimezone: true }).notNull().defaultNow(),
+    createdAt: timestamp11("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp11("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => [
+    uniqueIndex10("ext_projection_unique_field").on(
+      table.organizationId,
+      table.pluginId,
+      table.entity,
+      table.entityId,
+      table.field
+    ),
+    index9("ext_projection_entity_idx").on(
+      table.organizationId,
+      table.entity,
+      table.entityId
+    ),
+    index9("ext_projection_field_idx").on(
+      table.organizationId,
+      table.entity,
+      table.field,
+      table.status
+    ),
+    index9("ext_projection_ref_idx").on(
+      table.organizationId,
+      table.refEntity,
+      table.refId
+    )
+  ]
+);
+
+// src/schema/action-journal.ts
+import { index as index10, integer as integer5, pgTable as pgTable12, text as text12, timestamp as timestamp12, uniqueIndex as uniqueIndex11, varchar as varchar4 } from "drizzle-orm/pg-core";
+import { sql as sql2 } from "drizzle-orm";
+var ACTION_JOURNAL_STATUSES = [
+  "prepared",
+  "approval_pending",
+  "authorized",
+  "dispatched",
+  "succeeded",
+  "failed",
+  "unknown",
+  "reconciled",
+  "denied",
+  "expired"
+];
+var ACTION_JOURNAL_ACTIVE_STATUSES = [
+  "prepared",
+  "approval_pending",
+  "authorized",
+  "dispatched"
+];
+var actionExecutionJournal = pgTable12(
+  "action_execution_journal",
+  {
+    id: text12("id").primaryKey().default(sql2`gen_random_uuid()`),
+    organizationId: text12("organization_id").notNull(),
+    /** Authorizing subject. The only permission source (plan §4.3 B2). */
+    principalUserId: text12("principal_user_id").notNull(),
+    /** Who initiated, e.g. `agent:<pluginId>`. Audit chain only, never authorization. */
+    invoker: text12("invoker").notNull(),
+    /** Stable Action Contract id, decoupled from the procedure path. */
+    actionId: text12("action_id").notNull(),
+    revision: integer5("revision").notNull(),
+    /** Canonicalized argument hash; binds the approval token to these arguments. */
+    argsHash: text12("args_hash").notNull(),
+    /** Approval token nonce, or an `auto-` prefixed value for ungated executions. */
+    nonce: text12("nonce").notNull(),
+    status: varchar4("status", { length: 24, enum: ACTION_JOURNAL_STATUSES }).notNull().$type().default("prepared"),
+    attempt: integer5("attempt").notNull().default(0),
+    /** Target-system identifier used to reconcile `unknown` executions. */
+    externalRef: text12("external_ref"),
+    errorCode: text12("error_code"),
+    /** Resolved verdict recorded by reconciliation. */
+    outcome: text12("outcome"),
+    createdAt: timestamp12("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp12("updated_at", { withTimezone: true }).notNull().defaultNow(),
+    dispatchedAt: timestamp12("dispatched_at", { withTimezone: true }),
+    terminalAt: timestamp12("terminal_at", { withTimezone: true })
+  },
+  (table) => [
+    uniqueIndex11("action_execution_journal_nonce_uidx").on(table.nonce),
+    uniqueIndex11("action_execution_journal_active_uidx").on(table.organizationId, table.actionId, table.argsHash).where(sql2`${table.status} IN ('prepared','approval_pending','authorized','dispatched')`),
+    index10("action_execution_journal_status_idx").on(table.status, table.updatedAt),
+    index10("action_execution_journal_org_idx").on(table.organizationId, table.createdAt)
+  ]
+);
+var actionExecutionOutbox = pgTable12(
+  "action_execution_outbox",
+  {
+    id: text12("id").primaryKey().default(sql2`gen_random_uuid()`),
+    journalId: text12("journal_id").notNull().references(() => actionExecutionJournal.id, { onDelete: "cascade" }),
+    kind: text12("kind").notNull(),
+    availableAt: timestamp12("available_at", { withTimezone: true }).notNull().defaultNow(),
+    attempts: integer5("attempts").notNull().default(0),
+    lockedAt: timestamp12("locked_at", { withTimezone: true }),
+    lockToken: text12("lock_token")
+  },
+  (table) => [index10("action_execution_outbox_available_idx").on(table.availableAt)]
+);
+
+// src/schema/settings.ts
+import {
+  pgTable as pgTable13,
+  text as text13,
+  timestamp as timestamp13,
+  jsonb as jsonb7,
+  index as index11,
+  boolean as boolean8,
+  integer as integer6,
+  uniqueIndex as uniqueIndex12
+} from "drizzle-orm/pg-core";
+import { sql as sql3 } from "drizzle-orm";
+import { createInsertSchema as createInsertSchema11 } from "drizzle-orm/zod";
+import { z as z6 } from "zod/v4";
+var settings = pgTable13(
+  "settings",
+  {
+    id: text13("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // Scope identification
+    scope: text13("scope").notNull().$type(),
+    scopeId: text13("scope_id"),
+    // pluginId (only for plugin_* scopes)
+    // FK to organization table (nullable - only for tenant and plugin_tenant scopes)
+    organizationId: text13("organization_id").references(() => organization.id, { onDelete: "cascade" }),
+    // Setting data
+    key: text13("key").notNull(),
+    // Setting key (e.g., "email.smtp.host")
+    value: jsonb7("value"),
+    // Setting value (or EncryptedValue if encrypted)
+    valueType: text13("value_type").$type().default("string"),
+    // Encryption
+    encrypted: boolean8("encrypted").notNull().default(false),
+    // Schema version for migration support
+    schemaVersion: integer6("schema_version").notNull().default(1),
+    // Metadata
+    description: text13("description"),
+    // Audit fields
+    createdBy: text13("created_by"),
+    updatedBy: text13("updated_by"),
+    createdAt: timestamp13("created_at").notNull().defaultNow(),
+    updatedAt: timestamp13("updated_at").notNull().defaultNow().$onUpdate(() => /* @__PURE__ */ new Date())
+  },
+  (table) => [
+    // Unique constraint with COALESCE to handle NULL values
+    uniqueIndex12("idx_settings_unique").on(
+      table.scope,
+      sql3`COALESCE(${table.scopeId}, '')`,
+      sql3`COALESCE(${table.organizationId}, '')`,
+      table.key
+    ),
+    // Index for scope + key queries
+    index11("idx_settings_scope_key").on(table.scope, table.key),
+    // Index for tenant queries (partial)
+    index11("idx_settings_tenant").on(table.organizationId),
+    // Index for plugin queries (partial)
+    index11("idx_settings_plugin").on(table.scopeId)
+  ]
+);
+var settingSchemas = pgTable13(
+  "setting_schemas",
+  {
+    id: text13("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // Pattern matching (supports wildcards, e.g., "email.*" or "plugin:*:api_key")
+    keyPattern: text13("key_pattern").notNull(),
+    // JSON Schema definition
+    schema: jsonb7("schema").notNull().$type(),
+    // Version for schema evolution
+    version: integer6("version").notNull().default(1),
+    // Default value if setting doesn't exist
+    defaultValue: jsonb7("default_value"),
+    // Metadata
+    description: text13("description"),
+    deprecated: boolean8("deprecated").notNull().default(false),
+    createdAt: timestamp13("created_at").notNull().defaultNow()
+  },
+  (table) => [
+    // Unique constraint on pattern + version
+    uniqueIndex12("idx_setting_schemas_pattern_version").on(
+      table.keyPattern,
+      table.version
+    )
+  ]
+);
+var settingScopeSchema = z6.enum(["global", "tenant", "plugin_global", "plugin_tenant"]);
+var settingValueTypeSchema = z6.enum(["string", "number", "boolean", "json"]);
+var settingSchema = createInsertSchema11(settings);
+var settingSchemaSchema = createInsertSchema11(settingSchemas);
+var getSettingQuery = settingSchema.pick({
+  scope: true,
+  key: true,
+  organizationId: true,
+  scopeId: true
+}).extend({
+  defaultValue: z6.unknown().optional()
+});
+var listSettingsQuery = settingSchema.pick({
+  scope: true,
+  organizationId: true,
+  scopeId: true
+}).merge(paginationSchema).extend({
+  keyPrefix: z6.string().optional()
+});
+var setSettingMutation = settingSchema.pick({
+  scope: true,
+  key: true,
+  value: true,
+  organizationId: true,
+  scopeId: true,
+  encrypted: true,
+  description: true,
+  valueType: true
+});
+var deleteSettingMutation = settingSchema.pick({
+  scope: true,
+  key: true,
+  organizationId: true,
+  scopeId: true
+});
+
+// src/schema/feature-flags.ts
+import {
+  pgTable as pgTable14,
+  text as text14,
+  timestamp as timestamp14,
+  jsonb as jsonb8,
+  index as index12,
+  boolean as boolean9,
+  integer as integer7,
+  uniqueIndex as uniqueIndex13
+} from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema12 } from "drizzle-orm/zod";
+import { z as z7 } from "zod/v4";
+var featureFlags = pgTable14(
+  "feature_flags",
+  {
+    id: text14("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // Identification
+    key: text14("key").notNull().unique(),
+    // Unique flag key (e.g., "dark_mode", "ai_features")
+    name: text14("name").notNull(),
+    // Display name
+    // Configuration
+    description: text14("description"),
+    enabled: boolean9("enabled").notNull().default(false),
+    // Rollout configuration
+    rolloutPercentage: integer7("rollout_percentage").notNull().default(100),
+    // 0-100
+    // Condition rules (evaluated in order, all must pass)
+    conditions: jsonb8("conditions").notNull().default([]).$type(),
+    // Audit fields
+    createdBy: text14("created_by"),
+    createdAt: timestamp14("created_at").notNull().defaultNow(),
+    updatedAt: timestamp14("updated_at").notNull().defaultNow().$onUpdate(() => /* @__PURE__ */ new Date())
+  },
+  (table) => [index12("idx_feature_flags_key").on(table.key)]
+);
+var featureFlagOverrides = pgTable14(
+  "feature_flag_overrides",
+  {
+    id: text14("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // References
+    flagId: text14("flag_id").notNull().references(() => featureFlags.id, { onDelete: "cascade" }),
+    // FK to organization table
+    organizationId: text14("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    // Override configuration
+    enabled: boolean9("enabled").notNull(),
+    rolloutPercentage: integer7("rollout_percentage"),
+    // NULL means use global value
+    conditions: jsonb8("conditions").$type(),
+    // NULL means use global conditions
+    // Audit fields
+    createdBy: text14("created_by"),
+    createdAt: timestamp14("created_at").notNull().defaultNow()
+  },
+  (table) => [
+    // Unique constraint: one override per flag per tenant
+    uniqueIndex13("idx_ff_overrides_flag_tenant").on(table.flagId, table.organizationId),
+    // Index for tenant lookups
+    index12("idx_ff_overrides_tenant").on(table.organizationId)
+  ]
+);
+var flagConditionSchema = z7.object({
+  type: z7.enum(["user_role", "tenant_plan", "user_id", "percentage"]),
+  operator: z7.enum(["eq", "neq", "in", "nin", "gt", "lt", "gte", "lte"]),
+  value: z7.unknown()
+});
+var featureFlagSchema = createInsertSchema12(featureFlags);
+var featureFlagOverrideSchema = createInsertSchema12(featureFlagOverrides);
+var organizationInputSchema = z7.object({
+  organizationId: z7.string().min(1).optional(),
+  tenantId: z7.string().min(1).optional()
+}).refine((data) => !!(data.organizationId ?? data.tenantId), {
+  message: "organizationId is required",
+  path: ["organizationId"]
+}).transform((data) => ({
+  organizationId: data.organizationId ?? data.tenantId
+}));
+var checkFeatureFlagQuery = z7.object({
+  key: z7.string(),
+  organizationId: z7.string().optional(),
+  tenantId: z7.string().optional(),
+  userId: z7.string().optional(),
+  userRole: z7.string().optional(),
+  tenantPlan: z7.string().optional()
+}).transform((data) => ({
+  ...data,
+  organizationId: data.organizationId ?? data.tenantId
+}));
+var getFeatureFlagQuery = z7.object({
+  key: z7.string().min(1)
+});
+var listFeatureFlagsQuery = paginationSchema.partial();
+var listFlagOverridesQuery = z7.object({
+  organizationId: z7.string().min(1).optional(),
+  tenantId: z7.string().min(1).optional()
+}).refine((data) => !!(data.organizationId ?? data.tenantId), {
+  message: "organizationId is required",
+  path: ["organizationId"]
+}).transform((data) => ({
+  organizationId: data.organizationId ?? data.tenantId
+}));
+var updateFeatureFlagMutation = featureFlagSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true
+}).partial().extend({
+  id: z7.string()
+  // Required for identification
+});
+var deleteFeatureFlagMutation = z7.object({
+  id: z7.string().uuid()
+});
+var setFlagOverrideMutation = z7.object({
+  flagKey: z7.string(),
+  organizationId: z7.string().optional(),
+  tenantId: z7.string().optional(),
+  enabled: z7.boolean(),
+  rolloutPercentage: z7.number().min(0).max(100).optional(),
+  conditions: z7.array(flagConditionSchema).optional()
+}).and(organizationInputSchema).transform((data) => ({
+  flagKey: data.flagKey,
+  organizationId: data.organizationId,
+  enabled: data.enabled,
+  rolloutPercentage: data.rolloutPercentage,
+  conditions: data.conditions
+}));
+var removeFlagOverrideMutation = z7.object({
+  flagKey: z7.string(),
+  organizationId: z7.string().optional(),
+  tenantId: z7.string().optional()
+}).and(organizationInputSchema).transform((data) => ({
+  flagKey: data.flagKey,
+  organizationId: data.organizationId
+}));
+
+// src/schema/media.ts
+import {
+  pgTable as pgTable15,
+  text as text15,
+  timestamp as timestamp15,
+  boolean as boolean10,
+  bigint,
+  integer as integer8,
+  jsonb as jsonb9,
+  index as index13,
+  uniqueIndex as uniqueIndex14,
+  check
+} from "drizzle-orm/pg-core";
+import { sql as sql4 } from "drizzle-orm";
+import { createInsertSchema as createInsertSchema13, createSelectSchema } from "drizzle-orm/zod";
+import { z as z8 } from "zod";
+var media = pgTable15(
+  "media",
+  {
+    id: text15("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    organizationId: text15("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    // Self-reference: variants point to their original media
+    parentId: text15("parent_id").references(() => media.id, { onDelete: "cascade" }),
+    variantName: text15("variant_name"),
+    // File information
+    filename: text15("filename").notNull(),
+    mimeType: text15("mime_type").notNull(),
+    size: bigint("size", { mode: "number" }).notNull().default(0),
+    // Storage information
+    storageProvider: text15("storage_provider").notNull().$type(),
+    storageKey: text15("storage_key").notNull(),
+    storageBucket: text15("storage_bucket"),
+    // Public access
+    publicUrl: text15("public_url"),
+    isPublic: boolean10("is_public").notNull().default(false),
+    // Integrity
+    checksum: text15("checksum"),
+    // Image-specific (null for non-image media)
+    width: integer8("width"),
+    height: integer8("height"),
+    format: text15("format"),
+    // CMS semantics
+    alt: text15("alt"),
+    title: text15("title"),
+    tags: text15("tags").array().default([]),
+    folderPath: text15("folder_path"),
+    // Extensible metadata
+    metadata: jsonb9("metadata").$type().default({}),
+    // Audit
+    createdBy: text15("created_by").notNull(),
+    createdAt: timestamp15("created_at").notNull().defaultNow(),
+    updatedAt: timestamp15("updated_at").notNull().defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()),
+    deletedAt: timestamp15("deleted_at")
+  },
+  (table) => [
+    // Storage key uniqueness per tenant
+    uniqueIndex14("media_storage_unique").on(
+      table.organizationId,
+      table.storageProvider,
+      table.storageKey
+    ),
+    // Variant name uniqueness per parent
+    uniqueIndex14("media_parent_variant_unique").on(table.parentId, table.variantName).where(sql4`${table.parentId} IS NOT NULL`),
+    // Prevent self-referencing
+    check("media_no_self_ref", sql4`${table.parentId} IS DISTINCT FROM ${table.id}`),
+    // Query indexes
+    index13("idx_media_org_folder").on(table.organizationId, table.folderPath).where(sql4`${table.deletedAt} IS NULL`),
+    index13("idx_media_org_mime").on(table.organizationId, table.mimeType).where(sql4`${table.deletedAt} IS NULL`),
+    index13("idx_media_parent").on(table.parentId).where(sql4`${table.parentId} IS NOT NULL`),
+    index13("idx_media_tags").using("gin", table.tags).where(sql4`${table.deletedAt} IS NULL`),
+    index13("idx_media_org_created").on(table.organizationId, table.createdAt).where(sql4`${table.deletedAt} IS NULL`),
+    index13("idx_media_deleted").on(table.deletedAt).where(sql4`${table.deletedAt} IS NOT NULL`)
+  ]
+);
+var mediaInsertSchema = createInsertSchema13(media);
+var mediaSelectSchema = createSelectSchema(media);
+var importMediaFromUrlMutation = z8.object({
+  url: z8.string().trim().url().max(2048),
+  providerId: z8.string().trim().min(1).max(100).optional()
+});
+
+// src/schema/web-design.ts
+import {
+  boolean as boolean11,
+  index as index14,
+  jsonb as jsonb10,
+  pgTable as pgTable16,
+  text as text16,
+  timestamp as timestamp16,
+  uniqueIndex as uniqueIndex15,
+  varchar as varchar5
+} from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema14, createSelectSchema as createSelectSchema2 } from "drizzle-orm/zod";
+import { z as z9 } from "zod";
+var WEB_PAGE_STATUSES = ["draft", "published", "archived"];
+var WEB_DOMAIN_STATUSES = ["pending", "verified", "active", "disabled"];
+var WEB_DOMAIN_CERTIFICATE_STATUSES = [
+  "not_requested",
+  "requested",
+  "provisioning",
+  "active",
+  "failed"
+];
+var WEB_PAGE_RESERVED_PATHS = [
+  "/favicon.ico",
+  "/robots.txt",
+  "/sitemap.xml",
+  "/manifest.json"
+];
+var WEB_PAGE_RESERVED_PREFIXES = [
+  "/_next",
+  "/api",
+  "/assets",
+  "/plugins",
+  "/static",
+  "/trpc"
+];
+function normalizeWebPagePath(value) {
+  const normalized = value.trim().replace(/^\/?/, "/").replace(/\/+/g, "/").replace(/\/$/, "").toLowerCase();
+  return normalized || "/";
+}
+var webPages = pgTable16(
+  "web_pages",
+  {
+    id: text16("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    organizationId: text16("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    title: text16("title").notNull(),
+    path: text16("path").notNull(),
+    status: varchar5("status", { length: 24, enum: WEB_PAGE_STATUSES }).notNull().default("draft"),
+    routeId: text16("route_id"),
+    templateId: text16("template_id"),
+    seoTitle: text16("seo_title"),
+    seoDescription: text16("seo_description"),
+    document: jsonb10("document").notNull().default({}).$type(),
+    publishedDocument: jsonb10("published_document").$type(),
+    publishedAt: timestamp16("published_at"),
+    createdBy: text16("created_by"),
+    updatedBy: text16("updated_by"),
+    createdAt: timestamp16("created_at").notNull().defaultNow(),
+    updatedAt: timestamp16("updated_at").notNull().defaultNow().$onUpdate(() => /* @__PURE__ */ new Date())
+  },
+  (table) => [
+    uniqueIndex15("web_pages_org_path_uidx").on(table.organizationId, table.path),
+    index14("web_pages_org_status_idx").on(table.organizationId, table.status),
+    index14("web_pages_route_idx").on(table.routeId)
+  ]
+);
+var webDomains = pgTable16(
+  "web_domains",
+  {
+    id: text16("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    organizationId: text16("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    hostname: text16("hostname").notNull(),
+    status: varchar5("status", { length: 24, enum: WEB_DOMAIN_STATUSES }).notNull().default("pending"),
+    isPrimary: boolean11("is_primary").notNull().default(false),
+    verificationToken: text16("verification_token"),
+    certificateStatus: varchar5("certificate_status", { length: 24, enum: WEB_DOMAIN_CERTIFICATE_STATUSES }).notNull().default("not_requested"),
+    certificateRequestedAt: timestamp16("certificate_requested_at"),
+    certificateIssuedAt: timestamp16("certificate_issued_at"),
+    certificateError: text16("certificate_error"),
+    verificationDetails: jsonb10("verification_details").$type(),
+    lastCheckedAt: timestamp16("last_checked_at"),
+    verifiedAt: timestamp16("verified_at"),
+    createdAt: timestamp16("created_at").notNull().defaultNow(),
+    updatedAt: timestamp16("updated_at").notNull().defaultNow().$onUpdate(() => /* @__PURE__ */ new Date())
+  },
+  (table) => [
+    uniqueIndex15("web_domains_hostname_uidx").on(table.hostname),
+    index14("web_domains_org_idx").on(table.organizationId),
+    index14("web_domains_status_idx").on(table.status)
+  ]
+);
+var webPageSchema = createInsertSchema14(webPages);
+var webPageSelectSchema = createSelectSchema2(webPages);
+var webDomainSchema = createInsertSchema14(webDomains);
+var webDomainSelectSchema = createSelectSchema2(webDomains);
+function normalizeWebDomainHostname(value) {
+  return value.trim().toLowerCase().replace(/\.$/, "");
+}
+function isValidWebDomainHostname(value) {
+  if (value.length > 253) return false;
+  if (value.includes("/") || value.includes("\\") || value.includes(":")) return false;
+  if (value === "localhost" || value.endsWith(".localhost")) return false;
+  if (/^\d{1,3}(\.\d{1,3}){3}$/.test(value)) return false;
+  const labels = value.split(".");
+  if (labels.length < 2) return false;
+  return labels.every((label) => label.length > 0 && label.length <= 63 && /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(label));
+}
+var webDomainHostnameSchema = z9.string().trim().min(1, "Hostname is required").max(253, "Hostname must be 253 characters or less").transform(normalizeWebDomainHostname).refine((hostname) => !/^[a-z][a-z\d+\-.]*:\/\//i.test(hostname), {
+  message: "Hostname must not include a protocol"
+}).refine(isValidWebDomainHostname, {
+  message: "Hostname must be a valid public domain name"
+});
+var webPagePathSchema = z9.string().trim().min(1, "Path is required").max(200, "Path must be 200 characters or less").transform(normalizeWebPagePath).refine((path) => !WEB_PAGE_RESERVED_PATHS.includes(path), {
+  message: "Path is reserved by the web host"
+}).refine((path) => !WEB_PAGE_RESERVED_PREFIXES.some((prefix) => path === prefix || path.startsWith(`${prefix}/`)), {
+  message: "Path uses a reserved system prefix"
+}).refine((path) => path === "/" || /^\/[a-z0-9][a-z0-9/_-]*$/.test(path), {
+  message: "Path must use lowercase letters, numbers, dashes, underscores, and slashes"
+}).refine((path) => !path.split("/").some((segment) => segment === "." || segment === ".."), {
+  message: "Path cannot contain dot segments"
+});
+var webDesignDocumentSchema = z9.record(z9.string(), z9.unknown());
+var createWebPageMutation = webPageSchema.pick({
+  title: true,
+  path: true,
+  status: true,
+  routeId: true,
+  templateId: true,
+  seoTitle: true,
+  seoDescription: true
+}).extend({
+  path: webPagePathSchema
+});
+var updateWebPageMutation = createWebPageMutation.partial();
+var getWebPageDocumentQuery = webPageSelectSchema.pick({
+  id: true
+});
+var saveWebPageDocumentMutation = getWebPageDocumentQuery.extend({
+  document: webDesignDocumentSchema
+});
+var publishWebPageMutation = getWebPageDocumentQuery;
+var createWebDomainMutation = webDomainSchema.pick({
+  hostname: true
+}).extend({
+  hostname: webDomainHostnameSchema
+});
+var getWebDomainQuery = webDomainSelectSchema.pick({
+  id: true
+});
+var verifyWebDomainMutation = getWebDomainQuery;
+var requestWebDomainCertificateMutation = getWebDomainQuery;
+var updateWebDomainCertificateStatusMutation = getWebDomainQuery.extend({
+  status: z9.enum(WEB_DOMAIN_CERTIFICATE_STATUSES),
+  error: z9.string().trim().max(1e3).optional()
+});
+var setPrimaryWebDomainMutation = getWebDomainQuery;
+var disableWebDomainMutation = getWebDomainQuery;
+var deleteWebDomainMutation = getWebDomainQuery;
+
+// src/schema/site-presentation.ts
+import { sql as sql5 } from "drizzle-orm";
+import {
+  check as check2,
+  foreignKey,
+  index as index15,
+  integer as integer9,
+  jsonb as jsonb11,
+  pgTable as pgTable17,
+  text as text17,
+  timestamp as timestamp17,
+  uniqueIndex as uniqueIndex16,
+  varchar as varchar6
+} from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema15, createSelectSchema as createSelectSchema3 } from "drizzle-orm/zod";
+import { z as z10 } from "zod";
+var WEB_THEME_REVISION_STATUSES = [
+  "draft",
+  "published",
+  "archived",
+  "invalid"
+];
+var WEB_THEME_SELECTION_STATUSES = ["active", "safe_mode"];
+var webThemeRevisions = pgTable17(
+  "web_theme_revisions",
+  {
+    id: text17("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    organizationId: text17("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    pluginId: varchar6("plugin_id", { length: 160 }).notNull(),
+    pluginVersion: varchar6("plugin_version", { length: 80 }).notNull(),
+    revision: integer9("revision").notNull(),
+    status: varchar6("status", { length: 24, enum: WEB_THEME_REVISION_STATUSES }).notNull().$type().default("draft"),
+    version: integer9("version").notNull().default(1),
+    homeTarget: jsonb11("home_target").notNull().$type().default({ type: "default" }),
+    settings: jsonb11("settings").notNull().$type().default({}),
+    tokenOverrides: jsonb11("token_overrides").notNull().$type().default({}),
+    adapterConfig: jsonb11("adapter_config").notNull().$type().default({}),
+    embedConfig: jsonb11("embed_config").notNull().$type().default({}),
+    schemaVersions: jsonb11("schema_versions").notNull().$type().default({}),
+    compatibilitySnapshot: jsonb11("compatibility_snapshot").$type(),
+    createdBy: text17("created_by").notNull(),
+    updatedBy: text17("updated_by").notNull(),
+    publishedBy: text17("published_by"),
+    createdAt: timestamp17("created_at").notNull().defaultNow(),
+    updatedAt: timestamp17("updated_at").notNull().defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()),
+    publishedAt: timestamp17("published_at")
+  },
+  (table) => [
+    uniqueIndex16("web_theme_revisions_org_plugin_revision_uidx").on(
+      table.organizationId,
+      table.pluginId,
+      table.revision
+    ),
+    uniqueIndex16("web_theme_revisions_org_id_uidx").on(table.organizationId, table.id),
+    uniqueIndex16("web_theme_revisions_one_draft_uidx").on(table.organizationId, table.pluginId).where(sql5`${table.status} = 'draft'`),
+    index15("web_theme_revisions_org_plugin_history_idx").on(
+      table.organizationId,
+      table.pluginId,
+      table.createdAt
+    ),
+    index15("web_theme_revisions_org_status_idx").on(table.organizationId, table.status)
+  ]
+);
+var webThemeSelections = pgTable17(
+  "web_theme_selections",
+  {
+    organizationId: text17("organization_id").primaryKey().references(() => organization.id, { onDelete: "cascade" }),
+    activeRevisionId: text17("active_revision_id"),
+    previousRevisionId: text17("previous_revision_id"),
+    lastKnownCompatibleRevisionId: text17("last_known_compatible_revision_id"),
+    status: varchar6("status", { length: 24, enum: WEB_THEME_SELECTION_STATUSES }).notNull().$type().default("active"),
+    version: integer9("version").notNull().default(1),
+    diagnostics: jsonb11("diagnostics").notNull().$type().default([]),
+    safeModeReason: text17("safe_mode_reason"),
+    safeModeEnteredAt: timestamp17("safe_mode_entered_at"),
+    updatedBy: text17("updated_by").notNull(),
+    createdAt: timestamp17("created_at").notNull().defaultNow(),
+    updatedAt: timestamp17("updated_at").notNull().defaultNow().$onUpdate(() => /* @__PURE__ */ new Date())
+  },
+  (table) => [
+    foreignKey({
+      name: "web_theme_selections_active_revision_fk",
+      columns: [table.organizationId, table.activeRevisionId],
+      foreignColumns: [webThemeRevisions.organizationId, webThemeRevisions.id]
+    }).onDelete("restrict"),
+    foreignKey({
+      name: "web_theme_selections_previous_revision_fk",
+      columns: [table.organizationId, table.previousRevisionId],
+      foreignColumns: [webThemeRevisions.organizationId, webThemeRevisions.id]
+    }).onDelete("restrict"),
+    foreignKey({
+      name: "web_theme_selections_last_compatible_revision_fk",
+      columns: [table.organizationId, table.lastKnownCompatibleRevisionId],
+      foreignColumns: [webThemeRevisions.organizationId, webThemeRevisions.id]
+    }).onDelete("restrict"),
+    check2(
+      "web_theme_selections_active_previous_distinct_chk",
+      sql5`${table.activeRevisionId} IS NULL OR ${table.previousRevisionId} IS NULL OR ${table.activeRevisionId} <> ${table.previousRevisionId}`
+    ),
+    index15("web_theme_selections_active_revision_idx").on(table.activeRevisionId),
+    index15("web_theme_selections_status_idx").on(table.status)
+  ]
+);
+var webThemePluginIdSchema = z10.string().min(3).max(160).regex(/^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)+$/);
+var webThemeHomeTargetSchema = z10.discriminatedUnion("type", [
+  z10.object({ type: z10.literal("theme-route"), routeId: z10.string().min(1).max(160) }),
+  z10.object({
+    type: z10.literal("plugin-route"),
+    pluginId: webThemePluginIdSchema,
+    routeId: z10.string().min(1).max(160)
+  }),
+  z10.object({ type: z10.literal("designer-page"), pageId: z10.string().min(1).max(160) }),
+  z10.object({ type: z10.literal("default") })
+]);
+var webThemeJsonObjectSchema = z10.record(z10.string(), z10.json());
+var webThemeAdapterSelectionSchema = z10.object({
+  ownerPluginId: webThemePluginIdSchema,
+  surfaceId: z10.string().min(1).max(160).regex(/^[a-z0-9][a-z0-9._-]*$/),
+  source: z10.enum(["theme", "plugin", "owner"]),
+  providerPluginId: webThemePluginIdSchema.optional()
+}).superRefine((selection, ctx) => {
+  if (selection.source === "plugin" && !selection.providerPluginId) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["providerPluginId"],
+      message: "plugin adapter selections require providerPluginId"
+    });
+  }
+  if (selection.source !== "plugin" && selection.providerPluginId) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["providerPluginId"],
+      message: "providerPluginId is only allowed for plugin adapter selections"
+    });
+  }
+});
+var webThemeAdapterConfigSchema = z10.object({
+  selections: z10.array(webThemeAdapterSelectionSchema).optional(),
+  providers: z10.record(webThemePluginIdSchema, webThemeJsonObjectSchema).optional()
+}).superRefine((config, ctx) => {
+  const targets = /* @__PURE__ */ new Set();
+  for (const [index28, selection] of (config.selections ?? []).entries()) {
+    const key = `${selection.ownerPluginId}:${selection.surfaceId}`;
+    if (targets.has(key)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["selections", index28, "surfaceId"],
+        message: `duplicate adapter selection target: ${key}`
+      });
+    }
+    targets.add(key);
+  }
+});
+var webThemeRevisionSchema = createInsertSchema15(webThemeRevisions, {
+  homeTarget: () => webThemeHomeTargetSchema,
+  settings: () => webThemeJsonObjectSchema,
+  tokenOverrides: () => webThemeJsonObjectSchema,
+  adapterConfig: () => webThemeAdapterConfigSchema,
+  embedConfig: () => webThemeJsonObjectSchema,
+  schemaVersions: () => z10.record(z10.string(), z10.number().int().nonnegative())
+});
+var webThemeRevisionSelectSchema = createSelectSchema3(webThemeRevisions);
+var webThemeSelectionSchema = createInsertSchema15(webThemeSelections);
+var webThemeSelectionSelectSchema = createSelectSchema3(webThemeSelections);
+var getWebThemeQuery = z10.object({ pluginId: webThemePluginIdSchema });
+var setWebThemeEnabledMutation = getWebThemeQuery.extend({ enabled: z10.boolean() });
+var getWebThemeRevisionQuery = webThemeRevisionSelectSchema.pick({ id: true });
+var listWebThemeRevisionsQuery = getWebThemeQuery.merge(paginationSchema);
+var saveWebThemeDraftMutation = getWebThemeQuery.extend({
+  expectedVersion: z10.number().int().positive().optional(),
+  homeTarget: webThemeHomeTargetSchema.optional(),
+  settings: webThemeJsonObjectSchema.optional(),
+  tokenOverrides: webThemeJsonObjectSchema.optional(),
+  adapterConfig: webThemeAdapterConfigSchema.optional(),
+  embedConfig: webThemeJsonObjectSchema.optional()
+});
+var activateWebThemeMutation = getWebThemeQuery.extend({
+  expectedSelectionVersion: z10.number().int().positive().optional()
+});
+var activateWebThemeRevisionMutation = getWebThemeRevisionQuery.extend({
+  expectedSelectionVersion: z10.number().int().positive().optional()
+});
+var publishWebThemeDraftMutation = getWebThemeRevisionQuery.extend({
+  expectedDraftVersion: z10.number().int().positive(),
+  expectedSelectionVersion: z10.number().int().positive().optional()
+});
+var rollbackWebThemeRevisionMutation = getWebThemeRevisionQuery.extend({
+  expectedSelectionVersion: z10.number().int().positive()
+});
+var issueWebThemePreviewMutation = getWebThemeRevisionQuery.extend({
+  host: z10.string().trim().min(1).max(253),
+  pageId: z10.string().min(1).max(160).optional(),
+  expiresInSeconds: z10.number().int().min(30).max(900).optional()
+});
+var recoverWebThemeMutation = z10.object({
+  expectedSelectionVersion: z10.number().int().positive(),
+  revisionId: z10.string().min(1).optional()
+});
+
+// src/schema/notifications.ts
+import {
+  pgTable as pgTable18,
+  text as text18,
+  timestamp as timestamp18,
+  jsonb as jsonb12,
+  boolean as boolean12,
+  integer as integer10,
+  index as index16
+} from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema16 } from "drizzle-orm/zod";
+var NotificationTypeEnum = {
+  // System / SaaS
+  SYSTEM_ALERT: "system_alert",
+  SYSTEM_WARNING: "system_warning",
+  TASK_ASSIGNED: "task_assigned",
+  TASK_COMPLETED: "task_completed",
+  EXPORT_READY: "export_ready",
+  // Collaboration
+  COMMENT_ADDED: "comment_added",
+  COMMENT_REPLIED: "comment_replied",
+  MENTIONED: "mentioned",
+  // Social (reserved for future)
+  POST_LIKED: "post_liked",
+  POST_COMMENTED: "post_commented",
+  USER_FOLLOWED: "user_followed"
+};
+var notifications = pgTable18(
+  "notifications",
+  {
+    id: text18("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // FK to user table
+    userId: text18("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+    // FK to organization table
+    organizationId: text18("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    // Actor/Entity for better UI rendering
+    actorId: text18("actor_id"),
+    entityId: text18("entity_id"),
+    entityType: text18("entity_type"),
+    // Template reference
+    templateKey: text18("template_key"),
+    templateVariables: jsonb12("template_variables").$type(),
+    // Content (rendered)
+    type: text18("type").notNull().$type(),
+    title: text18("title").notNull(),
+    message: text18("message").notNull(),
+    link: text18("link"),
+    // Status
+    read: boolean12("read").notNull().default(false),
+    archived: boolean12("archived").notNull().default(false),
+    // Channel tracking
+    channelsSent: jsonb12("channels_sent").$type(),
+    channelsFailed: jsonb12("channels_failed").$type(),
+    emailSent: boolean12("email_sent").notNull().default(false),
+    emailSentAt: timestamp18("email_sent_at"),
+    // Grouping/Bundling support
+    groupKey: text18("group_key"),
+    groupCount: integer10("group_count").notNull().default(1),
+    // Idempotency
+    idempotencyKey: text18("idempotency_key").unique(),
+    // Source tracking
+    sourcePluginId: text18("source_plugin_id"),
+    // Priority
+    priority: text18("priority").notNull().default("normal").$type(),
+    // Source - who triggered the notification (system/plugin/user)
+    source: text18("source").notNull().default("system").$type(),
+    // Category - determines retention policy and view strategy
+    category: text18("category").notNull().default("system").$type(),
+    // Latest Actors - for aggregation display ("Alice and 4 others...")
+    latestActors: jsonb12("latest_actors").$type().default([]),
+    // Pinned - for system alerts that need to stay at top
+    pinned: boolean12("pinned").notNull().default(false),
+    // Visual Priority - for UI styling
+    visualPriority: text18("visual_priority").notNull().default("medium").$type(),
+    // Actor info - structured actor data for rendering
+    actor: jsonb12("actor").$type(),
+    // Target info - what the notification is about
+    target: jsonb12("target").$type(),
+    // Aggregation Strategy - how to group notifications
+    aggregationStrategy: text18("aggregation_strategy").notNull().default("none").$type(),
+    // Metadata includes decisionTrace for debugging
+    metadata: jsonb12("metadata").$type(),
+    // Timestamps
+    createdAt: timestamp18("created_at").notNull().defaultNow(),
+    expiresAt: timestamp18("expires_at")
+  },
+  (table) => [
+    index16("idx_notifications_user_read").on(table.userId, table.read),
+    index16("idx_notifications_template").on(table.templateKey),
+    index16("idx_notifications_group").on(table.groupKey),
+    index16("idx_notifications_expires").on(table.expiresAt),
+    index16("idx_notifications_tenant_user").on(table.organizationId, table.userId),
+    index16("idx_notifications_category").on(table.category),
+    index16("idx_notifications_source").on(table.source),
+    index16("idx_notifications_pinned").on(table.pinned),
+    index16("idx_notifications_cleanup").on(table.category, table.read, table.createdAt)
+  ]
+);
+var notificationSchema = createInsertSchema16(notifications);
+
+// src/schema/notification-templates.ts
+import {
+  pgTable as pgTable19,
+  text as text19,
+  timestamp as timestamp19,
+  jsonb as jsonb13,
+  boolean as boolean13,
+  integer as integer11,
+  index as index17
+} from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema17 } from "drizzle-orm/zod";
+var notificationTemplates = pgTable19(
+  "notification_templates",
+  {
+    id: text19("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // Unique key (e.g., 'comment.new', 'order.shipped')
+    key: text19("key").notNull().unique(),
+    // Display name
+    name: text19("name").notNull(),
+    description: text19("description"),
+    // Category
+    category: text19("category").notNull().$type(),
+    // i18n content
+    title: jsonb13("title").notNull().$type(),
+    message: jsonb13("message").notNull().$type(),
+    // Variables that can be interpolated
+    variables: jsonb13("variables").$type(),
+    // Default channels for this template
+    defaultChannels: jsonb13("default_channels").notNull().default(["in-app"]).$type(),
+    // Priority
+    priority: text19("priority").notNull().default("normal").$type(),
+    // Plugin reference (if registered by plugin)
+    pluginId: text19("plugin_id"),
+    // Template evolution
+    deprecated: boolean13("deprecated").notNull().default(false),
+    version: integer11("version").notNull().default(1),
+    // Timestamps
+    createdAt: timestamp19("created_at").notNull().defaultNow(),
+    updatedAt: timestamp19("updated_at").notNull().defaultNow()
+  },
+  (table) => [
+    index17("idx_templates_plugin").on(table.pluginId),
+    index17("idx_templates_category").on(table.category)
+  ]
+);
+var notificationTemplateSchema = createInsertSchema17(notificationTemplates);
+
+// src/schema/notification-channels.ts
+import {
+  pgTable as pgTable20,
+  text as text20,
+  timestamp as timestamp20,
+  jsonb as jsonb14,
+  boolean as boolean14,
+  index as index18
+} from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema18 } from "drizzle-orm/zod";
+var notificationChannels = pgTable20(
+  "notification_channels",
+  {
+    id: text20("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // Unique key (namespaced)
+    // Format: 'in-app' (Core) or 'plugin:{pluginId}:{channel}'
+    key: text20("key").notNull().unique(),
+    // Display name (i18n)
+    name: jsonb14("name").notNull().$type(),
+    // Description (i18n)
+    description: jsonb14("description").$type(),
+    // Icon name
+    icon: text20("icon"),
+    // Plugin reference
+    pluginId: text20("plugin_id").notNull(),
+    // Is this channel currently enabled
+    enabled: boolean14("enabled").notNull().default(true),
+    // User configuration schema (Zod schema as JSON)
+    configSchema: jsonb14("config_schema"),
+    // Timestamps
+    createdAt: timestamp20("created_at").notNull().defaultNow()
+  },
+  (table) => [
+    index18("idx_channels_plugin").on(table.pluginId),
+    index18("idx_channels_enabled").on(table.enabled)
+  ]
+);
+var notificationChannelSchema = createInsertSchema18(notificationChannels);
+
+// src/schema/notification-preferences.ts
+import {
+  pgTable as pgTable21,
+  text as text21,
+  timestamp as timestamp21,
+  jsonb as jsonb15,
+  uniqueIndex as uniqueIndex17
+} from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema19 } from "drizzle-orm/zod";
+var notificationPreferences = pgTable21(
+  "notification_preferences",
+  {
+    id: text21("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // FK to user table
+    userId: text21("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+    // FK to organization table
+    organizationId: text21("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    // Enabled channels (global)
+    enabledChannels: jsonb15("enabled_channels").notNull().default(["in-app"]).$type(),
+    // Per-template channel overrides
+    // e.g., { 'order.urgent': ['in-app', 'email', 'sms'] }
+    templateOverrides: jsonb15("template_overrides").$type(),
+    // Quiet hours (do not disturb)
+    quietHours: jsonb15("quiet_hours").$type(),
+    // Email digest frequency
+    emailFrequency: text21("email_frequency").notNull().default("instant").$type(),
+    // Timestamps
+    createdAt: timestamp21("created_at").notNull().defaultNow(),
+    updatedAt: timestamp21("updated_at").notNull().defaultNow()
+  },
+  (table) => [
+    uniqueIndex17("idx_preferences_user_tenant").on(
+      table.userId,
+      table.organizationId
+    )
+  ]
+);
+var notificationPreferenceSchema = createInsertSchema19(notificationPreferences);
+
+// src/schema/audit-logs.ts
+import { pgTable as pgTable22, text as text22, timestamp as timestamp22, jsonb as jsonb16, index as index19 } from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema20 } from "drizzle-orm/zod";
+var auditLogs = pgTable22(
+  "audit_logs",
+  {
+    id: text22("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // Actor
+    actorType: text22("actor_type").notNull().$type(),
+    actorId: text22("actor_id").notNull(),
+    // FK to organization table
+    organizationId: text22("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    // Action
+    action: text22("action").notNull(),
+    resource: text22("resource"),
+    // Result
+    result: text22("result").notNull().$type(),
+    reason: text22("reason"),
+    // Metadata
+    metadata: jsonb16("metadata"),
+    // Audit enhancement fields
+    actorIp: text22("actor_ip"),
+    userAgent: text22("user_agent"),
+    traceId: text22("trace_id"),
+    createdAt: timestamp22("created_at").notNull().defaultNow()
+  },
+  (table) => [
+    index19("audit_logs_organization_idx").on(table.organizationId),
+    index19("audit_logs_actor_idx").on(table.actorType, table.actorId),
+    index19("audit_logs_action_idx").on(table.action),
+    index19("audit_logs_created_at_idx").on(table.createdAt),
+    index19("audit_logs_trace_idx").on(table.traceId)
+  ]
+);
+var auditLogSchema = createInsertSchema20(auditLogs);
+
+// src/schema/audit-events.ts
+import { pgTable as pgTable23, text as text23, timestamp as timestamp23, jsonb as jsonb17, index as index20 } from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema21 } from "drizzle-orm/zod";
+var auditEvents = pgTable23(
+  "audit_events",
+  {
+    id: text23("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // Entity identification
+    entityType: text23("entity_type").notNull(),
+    // 'setting', 'user', 'role', 'feature_flag', etc.
+    entityId: text23("entity_id"),
+    // Entity ID (can be NULL for batch operations)
+    // FK to organization table (nullable for global operations)
+    organizationId: text23("organization_id").references(() => organization.id, { onDelete: "cascade" }),
+    // Action
+    action: text23("action").notNull(),
+    // 'create', 'update', 'delete', 'login', 'logout', etc.
+    // Changes (flexible structure)
+    changes: jsonb17("changes").$type(),
+    // { old: {...}, new: {...} } or custom structure
+    metadata: jsonb17("metadata").$type(),
+    // Extra context
+    // Actor
+    actorId: text23("actor_id").notNull(),
+    actorType: text23("actor_type").notNull().$type().default("user"),
+    actorIp: text23("actor_ip"),
+    userAgent: text23("user_agent"),
+    // Correlation & Tracing
+    requestId: text23("request_id"),
+    // Request tracking ID
+    sessionId: text23("session_id"),
+    traceId: text23("trace_id"),
+    // Distributed trace ID
+    // Timestamp
+    createdAt: timestamp23("created_at").notNull().defaultNow()
+  },
+  (table) => [
+    // Index for entity queries
+    index20("audit_events_entity_idx").on(table.entityType, table.entityId),
+    // Index for tenant queries
+    index20("audit_events_organization_idx").on(table.organizationId),
+    // Index for actor queries
+    index20("audit_events_actor_idx").on(table.actorId),
+    // Index for time-based queries
+    index20("audit_events_time_idx").on(table.createdAt),
+    // Index for action queries
+    index20("audit_events_action_idx").on(table.entityType, table.action),
+    // Index for trace queries
+    index20("audit_events_trace_idx").on(table.traceId)
+  ]
+);
+var auditEventSchema = createInsertSchema21(auditEvents);
+
+// src/schema/audit-archive.ts
+import { pgTable as pgTable24, text as text24, timestamp as timestamp24, jsonb as jsonb18, index as index21 } from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema22 } from "drizzle-orm/zod";
+var auditEventsArchive = pgTable24(
+  "audit_events_archive",
+  {
+    id: text24("id").primaryKey(),
+    // Entity identification
+    entityType: text24("entity_type").notNull(),
+    entityId: text24("entity_id"),
+    // FK to organization table (nullable for global operations)
+    organizationId: text24("organization_id").references(() => organization.id, { onDelete: "set null" }),
+    // Action
+    action: text24("action").notNull(),
+    // Changes
+    changes: jsonb18("changes").$type(),
+    metadata: jsonb18("metadata").$type(),
+    // Actor
+    actorId: text24("actor_id").notNull(),
+    actorType: text24("actor_type").notNull().$type().default("user"),
+    actorIp: text24("actor_ip"),
+    userAgent: text24("user_agent"),
+    // Correlation & Tracing
+    requestId: text24("request_id"),
+    sessionId: text24("session_id"),
+    traceId: text24("trace_id"),
+    // Timestamps
+    createdAt: timestamp24("created_at").notNull(),
+    archivedAt: timestamp24("archived_at").notNull().defaultNow()
+  },
+  (table) => [
+    index21("audit_events_archive_entity_idx").on(table.entityType, table.entityId),
+    index21("audit_events_archive_organization_idx").on(table.organizationId),
+    index21("audit_events_archive_time_idx").on(table.createdAt)
+  ]
+);
+var auditLogsArchive = pgTable24(
+  "audit_logs_archive",
+  {
+    id: text24("id").primaryKey(),
+    // Actor
+    actorType: text24("actor_type").notNull().$type(),
+    actorId: text24("actor_id").notNull(),
+    // FK to organization table
+    organizationId: text24("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    // Action
+    action: text24("action").notNull(),
+    resource: text24("resource"),
+    // Result
+    result: text24("result").notNull().$type(),
+    reason: text24("reason"),
+    // Metadata
+    metadata: jsonb18("metadata"),
+    // Audit enhancement fields
+    actorIp: text24("actor_ip"),
+    userAgent: text24("user_agent"),
+    traceId: text24("trace_id"),
+    // Timestamps
+    createdAt: timestamp24("created_at").notNull(),
+    archivedAt: timestamp24("archived_at").notNull().defaultNow()
+  },
+  (table) => [
+    index21("audit_logs_archive_organization_idx").on(table.organizationId),
+    index21("audit_logs_archive_actor_idx").on(table.actorType, table.actorId),
+    index21("audit_logs_archive_time_idx").on(table.createdAt)
+  ]
+);
+var auditEventsArchiveSchema = createInsertSchema22(auditEventsArchive);
+var auditLogsArchiveSchema = createInsertSchema22(auditLogsArchive);
+
+// src/schema/entity-ownerships.ts
+import {
+  pgTable as pgTable25,
+  text as text25,
+  timestamp as timestamp25,
+  index as index22,
+  uniqueIndex as uniqueIndex18,
+  jsonb as jsonb19
+} from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema23 } from "drizzle-orm/zod";
+var ScopeType = {
+  USER: "user",
+  TEAM: "team",
+  ROLE: "role",
+  SPACE: "space",
+  ORG: "org"
+};
+var AccessLevel = {
+  READ: "read",
+  WRITE: "write"
+};
+var entityOwnerships = pgTable25(
+  "entity_ownerships",
+  {
+    id: text25("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // Target Entity
+    entityType: text25("entity_type").notNull(),
+    // 'article', 'document', etc.
+    entityId: text25("entity_id").notNull(),
+    // Scope (who has access)
+    scopeType: text25("scope_type").notNull(),
+    // 'user' | 'team' | 'role' | 'space' | 'org'
+    scopeId: text25("scope_id").notNull(),
+    // Access Level
+    level: text25("level").notNull().default("read"),
+    // 'read' | 'write'
+    // Inheritance Tracking (for rebuild)
+    inheritedFromType: text25("inherited_from_type"),
+    // 'team' | 'space' | null
+    inheritedFromId: text25("inherited_from_id"),
+    // Source scope ID
+    // FK to organization table
+    organizationId: text25("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    // Expiration (optional, for time-limited access)
+    expireAt: timestamp25("expire_at"),
+    // Metadata
+    createdAt: timestamp25("created_at").defaultNow().notNull(),
+    updatedAt: timestamp25("updated_at").defaultNow().notNull(),
+    createdBy: text25("created_by")
+    // Actor who granted this
+  },
+  (table) => [
+    // Unique constraint: one grant per entity-scope combination
+    uniqueIndex18("ownership_unique_idx").on(
+      table.entityType,
+      table.entityId,
+      table.scopeType,
+      table.scopeId
+    ),
+    // Query by entity
+    index22("ownership_entity_idx").on(table.entityType, table.entityId),
+    // Query by scope (who has access to what)
+    index22("ownership_scope_idx").on(table.scopeType, table.scopeId),
+    // Query inherited ownerships (for rebuild on membership change)
+    index22("ownership_inherited_idx").on(table.inheritedFromType, table.inheritedFromId),
+    // Tenant isolation
+    index22("ownership_org_idx").on(table.organizationId),
+    // Expiration cleanup
+    index22("ownership_expire_idx").on(table.expireAt)
+  ]
+);
+var ownershipAuditLog = pgTable25(
+  "ownership_audit_log",
+  {
+    id: text25("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // Reference to ownership (may be deleted)
+    ownershipId: text25("ownership_id").notNull(),
+    entityType: text25("entity_type").notNull(),
+    entityId: text25("entity_id").notNull(),
+    scopeType: text25("scope_type").notNull(),
+    scopeId: text25("scope_id").notNull(),
+    // Action
+    action: text25("action").notNull(),
+    // 'grant' | 'revoke' | 'inherit_expand' | 'inherit_collapse' | 'expire'
+    // State snapshot
+    beforeState: jsonb19("before_state"),
+    afterState: jsonb19("after_state"),
+    // Actor
+    actorId: text25("actor_id").notNull(),
+    actorType: text25("actor_type").notNull(),
+    // 'user' | 'system' | 'plugin'
+    reason: text25("reason"),
+    // FK to organization table
+    organizationId: text25("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    // Timestamp
+    timestamp: timestamp25("timestamp").defaultNow().notNull()
+  },
+  (table) => [
+    index22("audit_ownership_idx").on(table.ownershipId),
+    index22("audit_entity_idx").on(table.entityType, table.entityId),
+    index22("audit_actor_idx").on(table.actorId),
+    index22("audit_org_idx").on(table.organizationId),
+    index22("audit_timestamp_idx").on(table.timestamp)
+  ]
+);
+var entityOwnershipSchema = createInsertSchema23(entityOwnerships);
+var ownershipAuditLogSchema = createInsertSchema23(ownershipAuditLog);
+
+// src/schema/billing.ts
+import {
+  pgTable as pgTable26,
+  text as text26,
+  timestamp as timestamp26,
+  jsonb as jsonb20,
+  uuid,
+  integer as integer12,
+  index as index23,
+  uniqueIndex as uniqueIndex19
+} from "drizzle-orm/pg-core";
+import { sql as sql6 } from "drizzle-orm";
+import { createInsertSchema as createInsertSchema24 } from "drizzle-orm/zod";
+var capabilities = pgTable26(
+  "capabilities",
+  {
+    subject: text26("subject").primaryKey(),
+    type: text26("type").notNull().$type(),
+    unit: text26("unit"),
+    description: text26("description"),
+    source: text26("source").notNull().$type(),
+    pluginId: text26("plugin_id"),
+    status: text26("status").notNull().$type().default("pending"),
+    createdAt: timestamp26("created_at").notNull().defaultNow()
+  },
+  (table) => [
+    index23("idx_capabilities_source_status").on(table.source, table.status),
+    index23("idx_capabilities_plugin_id").on(table.pluginId)
+  ]
+);
+var plans = pgTable26("plans", {
+  id: text26("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+  name: text26("name").notNull(),
+  description: text26("description"),
+  interval: text26("interval").notNull().$type(),
+  intervalCount: integer12("interval_count").notNull().default(1),
+  currency: text26("currency").notNull().default("usd"),
+  priceCents: integer12("price_cents").notNull(),
+  isActive: integer12("is_active").notNull().default(1),
+  metadata: jsonb20("metadata").$type(),
+  createdAt: timestamp26("created_at").notNull().defaultNow(),
+  updatedAt: timestamp26("updated_at").notNull().defaultNow()
+});
+var planItems = pgTable26(
+  "plan_items",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    planId: text26("plan_id").notNull().references(() => plans.id, { onDelete: "cascade" }),
+    subject: text26("subject").notNull(),
+    procedurePath: text26("procedure_path"),
+    groupKey: text26("group_key"),
+    type: text26("type").notNull().$type(),
+    amount: integer12("amount"),
+    resetMode: text26("reset_mode").notNull().$type(),
+    priority: integer12("priority").notNull().default(0),
+    overagePolicy: text26("overage_policy").$type().default("deny"),
+    overagePriceCents: integer12("overage_price_cents"),
+    resetStrategy: text26("reset_strategy").$type().default("hard"),
+    resetCap: integer12("reset_cap"),
+    quotaScope: text26("quota_scope").$type().notNull().default("tenant"),
+    metadata: jsonb20("metadata").$type(),
+    createdAt: timestamp26("created_at").notNull().defaultNow(),
+    updatedAt: timestamp26("updated_at").notNull().defaultNow()
+  },
+  (table) => [
+    index23("idx_plan_items_plan_id").on(table.planId),
+    index23("idx_plan_items_subject").on(table.subject),
+    index23("idx_plan_items_procedure_path").on(table.procedurePath),
+    uniqueIndex19("uq_plan_items_plan_procedure_path").on(table.planId, table.procedurePath).where(sql6`${table.procedurePath} IS NOT NULL`)
+  ]
+);
+var userQuotas = pgTable26(
+  "user_quotas",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    userId: text26("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+    organizationId: text26("organization_id").references(() => organization.id, { onDelete: "cascade" }),
+    subject: text26("subject").notNull(),
+    balance: integer12("balance").notNull(),
+    priority: integer12("priority").notNull().default(0),
+    expiresAt: timestamp26("expires_at"),
+    sourceType: text26("source_type").notNull().$type(),
+    sourceId: text26("source_id").notNull(),
+    metadata: jsonb20("metadata").$type(),
+    createdAt: timestamp26("created_at").notNull().defaultNow(),
+    updatedAt: timestamp26("updated_at").notNull().defaultNow()
+  },
+  (table) => [
+    index23("idx_user_quotas_user_feature").on(table.userId, table.subject),
+    index23("idx_user_quotas_waterfall").on(
+      table.userId,
+      table.subject,
+      table.balance,
+      table.priority,
+      table.expiresAt
+    ),
+    uniqueIndex19("uq_user_quotas_source").on(
+      table.organizationId,
+      table.userId,
+      table.subject,
+      table.sourceType,
+      table.sourceId
+    ),
+    uniqueIndex19("uq_user_quotas_legacy_source").on(table.userId, table.subject, table.sourceType, table.sourceId).where(sql6`${table.organizationId} IS NULL`)
+  ]
+);
+var wallets = pgTable26("wallets", {
+  userId: text26("user_id").primaryKey().references(() => user.id, { onDelete: "cascade" }),
+  balanceCents: integer12("balance_cents").notNull().default(0),
+  currency: text26("currency").notNull().default("usd"),
+  updatedAt: timestamp26("updated_at").notNull().defaultNow()
+});
+var transactions = pgTable26(
+  "transactions",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    userId: text26("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+    amountCents: integer12("amount_cents").notNull(),
+    currency: text26("currency").notNull(),
+    sourceType: text26("source_type").notNull().$type(),
+    sourceId: text26("source_id").notNull(),
+    status: text26("status").notNull().$type().default("PENDING"),
+    gateway: text26("gateway"),
+    externalId: text26("external_id"),
+    baseCurrency: text26("base_currency"),
+    baseAmountCents: integer12("base_amount_cents"),
+    settlementCurrency: text26("settlement_currency"),
+    settlementAmountCents: integer12("settlement_amount_cents"),
+    exchangeRate: text26("exchange_rate"),
+    exchangeRateAt: timestamp26("exchange_rate_at"),
+    metadata: jsonb20("metadata").$type(),
+    paidAt: timestamp26("paid_at"),
+    createdAt: timestamp26("created_at").notNull().defaultNow(),
+    updatedAt: timestamp26("updated_at").notNull().defaultNow()
+  },
+  (table) => [
+    index23("idx_transactions_user_source").on(table.userId, table.sourceType, table.sourceId),
+    uniqueIndex19("uq_transactions_external_id").on(table.externalId),
+    index23("idx_transactions_status").on(table.status)
+  ]
+);
+var billingEventOutbox = pgTable26(
+  "billing_event_outbox",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    dedupeKey: text26("dedupe_key").notNull(),
+    transactionId: uuid("transaction_id").notNull().references(() => transactions.id, { onDelete: "cascade" }),
+    eventName: text26("event_name").notNull(),
+    payload: jsonb20("payload").notNull().$type(),
+    status: text26("status").notNull().$type().default("pending"),
+    attempts: integer12("attempts").notNull().default(0),
+    availableAt: timestamp26("available_at", { withTimezone: true }).notNull().defaultNow(),
+    claimId: uuid("claim_id"),
+    leaseExpiresAt: timestamp26("lease_expires_at", { withTimezone: true }),
+    lastError: text26("last_error"),
+    completedAt: timestamp26("completed_at", { withTimezone: true }),
+    createdAt: timestamp26("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp26("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => [
+    uniqueIndex19("billing_event_outbox_dedupe_uidx").on(table.dedupeKey),
+    index23("billing_event_outbox_available_idx").on(table.status, table.availableAt),
+    index23("billing_event_outbox_transaction_idx").on(table.transactionId)
+  ]
+);
+var usageRecords = pgTable26(
+  "usage_records",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    userId: text26("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+    subject: text26("subject").notNull(),
+    amount: integer12("amount").notNull(),
+    quotaIds: jsonb20("quota_ids").$type(),
+    overageChargedCents: integer12("overage_charged_cents"),
+    occurredAt: timestamp26("occurred_at").notNull().defaultNow(),
+    metadata: jsonb20("metadata").$type()
+  },
+  (table) => [
+    index23("idx_usage_records_user_feature").on(table.userId, table.subject),
+    index23("idx_usage_records_occurred_at").on(table.occurredAt)
+  ]
+);
+var planSubscriptions = pgTable26(
+  "plan_subscriptions",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    organizationId: text26("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    planId: text26("plan_id").notNull().references(() => plans.id, { onDelete: "restrict" }),
+    status: text26("status").notNull().$type(),
+    version: integer12("version").notNull().default(1),
+    currentPeriodStart: timestamp26("current_period_start").notNull(),
+    currentPeriodEnd: timestamp26("current_period_end").notNull(),
+    billingCycleAnchor: integer12("billing_cycle_anchor"),
+    trialStart: timestamp26("trial_start"),
+    trialEnd: timestamp26("trial_end"),
+    renewalCount: integer12("renewal_count").notNull().default(0),
+    lastRenewalAt: timestamp26("last_renewal_at"),
+    gateway: text26("gateway"),
+    externalSubscriptionId: text26("external_subscription_id"),
+    initialTransactionId: uuid("initial_transaction_id").references(() => transactions.id, { onDelete: "set null" }),
+    latestTransactionId: uuid("latest_transaction_id").references(() => transactions.id, { onDelete: "set null" }),
+    canceledAt: timestamp26("canceled_at"),
+    cancelReason: text26("cancel_reason"),
+    cancelAtPeriodEnd: integer12("cancel_at_period_end").default(0),
+    scheduledPlanId: text26("scheduled_plan_id").references(() => plans.id, { onDelete: "set null" }),
+    scheduledChangeAt: timestamp26("scheduled_change_at"),
+    metadata: jsonb20("metadata").$type(),
+    createdAt: timestamp26("created_at").notNull().defaultNow(),
+    updatedAt: timestamp26("updated_at").notNull().defaultNow()
+  },
+  (table) => [
+    index23("idx_subscriptions_tenant").on(table.organizationId),
+    index23("idx_subscriptions_status").on(table.status),
+    index23("idx_subscriptions_period_end").on(table.currentPeriodEnd),
+    uniqueIndex19("uq_subscriptions_external_id").on(table.externalSubscriptionId),
+    uniqueIndex19("uq_subscriptions_tenant_plan_active").on(table.organizationId, table.planId).where(sql6`status IN ('active', 'trialing', 'past_due')`)
+  ]
+);
+var tenantQuotas = pgTable26(
+  "tenant_quotas",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    organizationId: text26("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    subject: text26("subject").notNull(),
+    balance: integer12("balance").notNull(),
+    priority: integer12("priority").notNull().default(100),
+    expiresAt: timestamp26("expires_at"),
+    sourceType: text26("source_type").notNull().$type(),
+    sourceId: text26("source_id").notNull(),
+    metadata: jsonb20("metadata").$type(),
+    createdAt: timestamp26("created_at").notNull().defaultNow(),
+    updatedAt: timestamp26("updated_at").notNull().defaultNow()
+  },
+  (table) => [
+    index23("idx_tenant_quotas_tenant_feature").on(table.organizationId, table.subject),
+    index23("idx_tenant_quotas_waterfall").on(
+      table.organizationId,
+      table.subject,
+      table.balance,
+      table.priority,
+      table.expiresAt
+    ),
+    uniqueIndex19("uq_tenant_quotas_source").on(
+      table.organizationId,
+      table.subject,
+      table.sourceType,
+      table.sourceId
+    )
+  ]
+);
+var capabilitySchema = createInsertSchema24(capabilities);
+var planSchema = createInsertSchema24(plans);
+var planItemSchema = createInsertSchema24(planItems);
+var userQuotaSchema = createInsertSchema24(userQuotas);
+var walletSchema = createInsertSchema24(wallets);
+var transactionSchema = createInsertSchema24(transactions);
+var billingEventOutboxSchema = createInsertSchema24(billingEventOutbox);
+var usageRecordSchema = createInsertSchema24(usageRecords);
+var planSubscriptionSchema = createInsertSchema24(planSubscriptions);
+var tenantQuotaSchema = createInsertSchema24(tenantQuotas);
+
+// src/schema/currency.ts
+import {
+  pgTable as pgTable27,
+  text as text27,
+  timestamp as timestamp27,
+  jsonb as jsonb21,
+  uuid as uuid2,
+  integer as integer13,
+  index as index24,
+  uniqueIndex as uniqueIndex20,
+  numeric as numeric2
+} from "drizzle-orm/pg-core";
+import { sql as sql7 } from "drizzle-orm";
+import { createInsertSchema as createInsertSchema25 } from "drizzle-orm/zod";
+var currencies = pgTable27(
+  "currencies",
+  {
+    id: uuid2("id").primaryKey().defaultRandom(),
+    // FK to organization table
+    organizationId: text27("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    code: text27("code").notNull(),
+    // ISO 4217 uppercase (USD, CNY, EUR)
+    nameI18n: jsonb21("name_i18n").notNull().$type(),
+    symbol: text27("symbol").notNull(),
+    // '$', '¥', '€'
+    decimalDigits: integer13("decimal_digits").notNull().default(2),
+    isEnabled: integer13("is_enabled").notNull().default(1),
+    isBase: integer13("is_base").notNull().default(0),
+    currentRate: numeric2("current_rate", { precision: 18, scale: 8 }),
+    createdBy: text27("created_by"),
+    updatedBy: text27("updated_by"),
+    createdAt: timestamp27("created_at").notNull().defaultNow(),
+    updatedAt: timestamp27("updated_at").notNull().defaultNow()
+  },
+  (table) => [
+    uniqueIndex20("uq_currencies_org_code").on(table.organizationId, table.code),
+    uniqueIndex20("uq_currencies_org_base").on(table.organizationId).where(sql7`is_base = 1`),
+    index24("idx_currencies_org").on(table.organizationId)
+  ]
+);
+var exchangeRates = pgTable27(
+  "exchange_rates",
+  {
+    id: uuid2("id").primaryKey().defaultRandom(),
+    // FK to organization table
+    organizationId: text27("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    baseCurrency: text27("base_currency").notNull(),
+    targetCurrency: text27("target_currency").notNull(),
+    rate: numeric2("rate", { precision: 18, scale: 8 }).notNull(),
+    source: text27("source").notNull().$type(),
+    effectiveAt: timestamp27("effective_at").notNull(),
+    expiresAt: timestamp27("expires_at"),
+    createdBy: text27("created_by"),
+    updatedBy: text27("updated_by"),
+    createdAt: timestamp27("created_at").notNull().defaultNow(),
+    updatedAt: timestamp27("updated_at").notNull().defaultNow()
+  },
+  (table) => [
+    uniqueIndex20("uq_exchange_rates_org_pair_time").on(
+      table.organizationId,
+      table.baseCurrency,
+      table.targetCurrency,
+      table.effectiveAt
+    ),
+    index24("idx_exchange_rates_org").on(table.organizationId),
+    index24("idx_exchange_rates_current").on(
+      table.organizationId,
+      table.baseCurrency,
+      table.targetCurrency
+    ).where(sql7`expires_at IS NULL`)
+  ]
+);
+var currencySchema = createInsertSchema25(currencies);
+var exchangeRateSchema = createInsertSchema25(exchangeRates);
+
+// src/schema/geo.ts
+import {
+  pgTable as pgTable28,
+  text as text28,
+  timestamp as timestamp28,
+  boolean as boolean15,
+  integer as integer14,
+  jsonb as jsonb22,
+  index as index25,
+  uniqueIndex as uniqueIndex21
+} from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema26 } from "drizzle-orm/zod";
+import { z as z11 } from "zod/v4";
+var MARKET_REGIONS = [
+  { code: "north_america", name: { "zh-CN": "\u5317\u7F8E", "en-US": "North America" }, sortOrder: 10 },
+  { code: "europe", name: { "zh-CN": "\u6B27\u6D32", "en-US": "Europe" }, sortOrder: 20 },
+  { code: "asia_pacific", name: { "zh-CN": "\u4E9A\u592A", "en-US": "Asia Pacific" }, sortOrder: 30 },
+  { code: "latin_america", name: { "zh-CN": "\u62C9\u7F8E", "en-US": "Latin America" }, sortOrder: 40 },
+  { code: "middle_east", name: { "zh-CN": "\u4E2D\u4E1C", "en-US": "Middle East" }, sortOrder: 50 },
+  { code: "africa", name: { "zh-CN": "\u975E\u6D32", "en-US": "Africa" }, sortOrder: 60 },
+  { code: "global", name: { "zh-CN": "\u5168\u7403", "en-US": "Global" }, sortOrder: 70 }
+];
+var geoNameSchema = z11.record(z11.string(), z11.string()).refine((value) => Object.keys(value).length > 0, {
+  message: "At least one localized name is required"
+});
+var countryCode2Schema = z11.string().length(2).regex(/^[A-Za-z]{2}$/, "Country code must be ISO 3166-1 alpha-2").transform((value) => value.toUpperCase());
+var countryCode3Schema = z11.string().length(3).regex(/^[A-Za-z]{3}$/, "Country code must be ISO 3166-1 alpha-3").transform((value) => value.toUpperCase());
+var subdivisionFullCodeSchema = z11.string().min(4).regex(/^[A-Za-z]{2}-[A-Za-z0-9]+$/, "Subdivision code must look like ISO 3166-2").transform((value) => value.toUpperCase());
+var geoCountries = pgTable28(
+  "geo_countries",
+  {
+    id: text28("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    code2: text28("code2").notNull(),
+    code3: text28("code3"),
+    numericCode: text28("numeric_code"),
+    name: jsonb22("name").notNull().$type(),
+    officialName: jsonb22("official_name").$type(),
+    flags: jsonb22("flags").$type(),
+    currencyCode: text28("currency_code"),
+    languageCode: text28("language_code"),
+    locale: text28("locale"),
+    phoneCode: text28("phone_code"),
+    isSupported: boolean15("is_supported").notNull().default(true),
+    sortOrder: integer14("sort_order").notNull().default(0),
+    createdAt: timestamp28("created_at").notNull().defaultNow(),
+    updatedAt: timestamp28("updated_at").notNull().defaultNow().$onUpdate(() => /* @__PURE__ */ new Date())
+  },
+  (table) => [
+    uniqueIndex21("geo_countries_code2_uidx").on(table.code2),
+    uniqueIndex21("geo_countries_code3_uidx").on(table.code3),
+    index25("geo_countries_supported_sort_idx").on(table.isSupported, table.sortOrder)
+  ]
+);
+var geoSubdivisions = pgTable28(
+  "geo_subdivisions",
+  {
+    id: text28("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    countryCode2: text28("country_code2").notNull().references(() => geoCountries.code2, { onDelete: "cascade" }),
+    code: text28("code").notNull(),
+    fullCode: text28("full_code").notNull(),
+    name: jsonb22("name").notNull().$type(),
+    type: text28("type"),
+    isSupported: boolean15("is_supported").notNull().default(true),
+    sortOrder: integer14("sort_order").notNull().default(0),
+    createdAt: timestamp28("created_at").notNull().defaultNow(),
+    updatedAt: timestamp28("updated_at").notNull().defaultNow().$onUpdate(() => /* @__PURE__ */ new Date())
+  },
+  (table) => [
+    uniqueIndex21("geo_subdivisions_full_code_uidx").on(table.fullCode),
+    uniqueIndex21("geo_subdivisions_country_code_uidx").on(table.countryCode2, table.code),
+    index25("geo_subdivisions_country_sort_idx").on(table.countryCode2, table.sortOrder),
+    index25("geo_subdivisions_country_supported_idx").on(table.countryCode2, table.isSupported)
+  ]
+);
+var geoCountrySchema = createInsertSchema26(geoCountries, {
+  code2: () => countryCode2Schema,
+  code3: () => countryCode3Schema.optional(),
+  name: () => geoNameSchema,
+  officialName: () => geoNameSchema.nullish()
+});
+var geoSubdivisionSchema = createInsertSchema26(geoSubdivisions, {
+  countryCode2: () => countryCode2Schema,
+  fullCode: () => subdivisionFullCodeSchema,
+  name: () => geoNameSchema
+});
+var getGeoCountryQuery = z11.object({
+  code2: countryCode2Schema,
+  locale: localeSchema.optional()
+});
+var listGeoCountriesQuery = paginationSchema.partial().extend({
+  limit: z11.number().int().min(1).max(300).default(300),
+  offset: z11.number().int().min(0).default(0),
+  locale: localeSchema.optional(),
+  supportedOnly: z11.boolean().default(true)
+});
+var getGeoSubdivisionQuery = z11.object({
+  fullCode: subdivisionFullCodeSchema,
+  locale: localeSchema.optional()
+});
+var listGeoSubdivisionsQuery = paginationSchema.partial().extend({
+  limit: z11.number().int().min(1).max(500).default(500),
+  offset: z11.number().int().min(0).default(0),
+  countryCode2: countryCode2Schema,
+  locale: localeSchema.optional(),
+  supportedOnly: z11.boolean().default(true)
+});
+var listMarketRegionsQuery = paginationSchema.partial().extend({
+  limit: z11.number().int().min(1).max(100).default(100),
+  offset: z11.number().int().min(0).default(0),
+  locale: localeSchema.optional()
+});
+
+// src/schema/webhooks.ts
+import {
+  pgTable as pgTable29,
+  text as text29,
+  timestamp as timestamp29,
+  boolean as boolean16,
+  jsonb as jsonb23,
+  integer as integer15,
+  index as index26,
+  uniqueIndex as uniqueIndex22
+} from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema27 } from "drizzle-orm/zod";
+var webhookEndpoints = pgTable29(
+  "webhook_endpoints",
+  {
+    id: text29("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // FK to organization table
+    organizationId: text29("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    url: text29("url").notNull(),
+    secret: text29("secret").notNull(),
+    events: text29("events").array().notNull().$defaultFn(() => []),
+    enabled: boolean16("enabled").notNull().default(true),
+    retryPolicy: jsonb23("retry_policy").notNull().$type().default({ attempts: 5, backoffMs: 1e3 }),
+    createdAt: timestamp29("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp29("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => [
+    index26("idx_webhook_endpoints_tenant").on(table.organizationId),
+    index26("idx_webhook_endpoints_enabled").on(table.organizationId, table.enabled),
+    uniqueIndex22("uq_webhook_endpoints_tenant_url").on(table.organizationId, table.url)
+  ]
+);
+var webhookDeliveries = pgTable29(
+  "webhook_deliveries",
+  {
+    id: text29("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // FK to organization table
+    organizationId: text29("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    // FK to webhookEndpoints table
+    endpointId: text29("endpoint_id").notNull().references(() => webhookEndpoints.id, { onDelete: "cascade" }),
+    eventType: text29("event_type").notNull(),
+    payload: jsonb23("payload").notNull().$type(),
+    status: text29("status").notNull().$type().default("pending"),
+    attempts: integer15("attempts").notNull().default(0),
+    lastAttemptAt: timestamp29("last_attempt_at", { withTimezone: true }),
+    responseCode: integer15("response_code"),
+    error: text29("error"),
+    dedupeKey: text29("dedupe_key").notNull(),
+    createdAt: timestamp29("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp29("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => [
+    index26("idx_webhook_deliveries_endpoint").on(table.endpointId),
+    index26("idx_webhook_deliveries_tenant_status").on(table.organizationId, table.status),
+    uniqueIndex22("idx_webhook_deliveries_dedupe").on(table.dedupeKey),
+    index26("idx_webhook_deliveries_created").on(table.createdAt)
+  ]
+);
+var webhookOutbox = pgTable29(
+  "webhook_outbox",
+  {
+    id: text29("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // FK to organization table
+    organizationId: text29("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    // FK to webhookEndpoints table
+    endpointId: text29("endpoint_id").notNull().references(() => webhookEndpoints.id, { onDelete: "cascade" }),
+    eventType: text29("event_type").notNull(),
+    payload: jsonb23("payload").notNull().$type(),
+    dedupeKey: text29("dedupe_key").notNull(),
+    availableAt: timestamp29("available_at", { withTimezone: true }).notNull().defaultNow(),
+    lockedAt: timestamp29("locked_at", { withTimezone: true }),
+    lockToken: text29("lock_token"),
+    createdAt: timestamp29("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => [
+    index26("idx_webhook_outbox_available").on(table.availableAt),
+    uniqueIndex22("idx_webhook_outbox_dedupe").on(table.dedupeKey),
+    index26("idx_webhook_outbox_tenant").on(table.organizationId)
+  ]
+);
+var webhookEndpointSchema = createInsertSchema27(webhookEndpoints);
+var webhookDeliverySchema = createInsertSchema27(webhookDeliveries);
+var webhookOutboxSchema = createInsertSchema27(webhookOutbox);
+
+// src/schema/scheduled-tasks.ts
+import {
+  pgTable as pgTable30,
+  text as text30,
+  timestamp as timestamp30,
+  jsonb as jsonb24,
+  boolean as boolean17,
+  integer as integer16,
+  real,
+  index as index27
+} from "drizzle-orm/pg-core";
+import { createInsertSchema as createInsertSchema28 } from "drizzle-orm/zod";
+var scheduledTasks = pgTable30(
+  "scheduled_tasks",
+  {
+    id: text30("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // FK to organization table
+    organizationId: text30("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    name: text30("name").notNull(),
+    description: text30("description"),
+    cronExpression: text30("cron_expression").notNull(),
+    timezone: text30("timezone").notNull().default("UTC"),
+    handlerType: text30("handler_type").$type().notNull(),
+    handlerConfig: jsonb24("handler_config").notNull().$type(),
+    payload: jsonb24("payload"),
+    enabled: boolean17("enabled").notNull().default(true),
+    lastRunAt: timestamp30("last_run_at", { withTimezone: true }),
+    lastStatus: text30("last_status").$type(),
+    nextRunAt: timestamp30("next_run_at", { withTimezone: true }).notNull(),
+    consecutiveFailures: integer16("consecutive_failures").notNull().default(0),
+    maxRetries: integer16("max_retries").notNull().default(3),
+    retryBackoffMultiplier: real("retry_backoff_multiplier").notNull().default(2),
+    providerId: text30("provider_id").notNull().default("builtin"),
+    providerMetadata: jsonb24("provider_metadata"),
+    createdBy: text30("created_by").notNull(),
+    createdByType: text30("created_by_type").$type().notNull(),
+    createdAt: timestamp30("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp30("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => [
+    index27("scheduled_tasks_organization_idx").on(table.organizationId),
+    index27("scheduled_tasks_next_run_idx").on(table.nextRunAt, table.enabled),
+    index27("scheduled_tasks_provider_idx").on(table.providerId)
+  ]
+);
+var taskExecutions = pgTable30(
+  "task_executions",
+  {
+    id: text30("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    // FK to scheduledTasks table
+    taskId: text30("task_id").notNull().references(() => scheduledTasks.id, { onDelete: "cascade" }),
+    // FK to organization table
+    organizationId: text30("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    scheduledAt: timestamp30("scheduled_at", { withTimezone: true }).notNull(),
+    startedAt: timestamp30("started_at", { withTimezone: true }).notNull(),
+    completedAt: timestamp30("completed_at", { withTimezone: true }),
+    status: text30("status").$type().notNull(),
+    attempt: integer16("attempt").notNull().default(1),
+    result: jsonb24("result"),
+    error: jsonb24("error").$type(),
+    lockKey: text30("lock_key").notNull(),
+    workerId: text30("worker_id").notNull()
+  },
+  (table) => [
+    index27("task_executions_task_idx").on(table.taskId, table.startedAt),
+    index27("task_executions_organization_idx").on(table.organizationId),
+    index27("task_executions_status_idx").on(table.status)
+  ]
+);
+var schedulerProviders = pgTable30(
+  "scheduler_providers",
+  {
+    id: text30("id").primaryKey(),
+    name: text30("name").notNull(),
+    version: text30("version").notNull(),
+    pluginId: text30("plugin_id"),
+    capabilities: jsonb24("capabilities").notNull().$type(),
+    status: text30("status").$type().notNull(),
+    registeredAt: timestamp30("registered_at", { withTimezone: true }).notNull().defaultNow(),
+    unregisteredAt: timestamp30("unregistered_at", { withTimezone: true })
+  },
+  (table) => [
+    index27("scheduler_providers_plugin_idx").on(table.pluginId),
+    index27("scheduler_providers_status_idx").on(table.status)
+  ]
+);
+var scheduledTaskSchema = createInsertSchema28(scheduledTasks);
+var taskExecutionSchema = createInsertSchema28(taskExecutions);
+var schedulerProviderSchema = createInsertSchema28(schedulerProviders);
+
+export {
+  user,
+  session,
+  CREDENTIAL_ACCOUNT_ISSUER,
+  account,
+  verification,
+  organization,
+  member,
+  invitation,
+  apikey,
+  userSchema,
+  sessionSchema,
+  accountSchema,
+  verificationSchema,
+  organizationSchema,
+  memberSchema,
+  invitationSchema,
+  apikeySchema,
+  updateProfileMutation,
+  team,
+  teamMember,
+  teamSchema,
+  teamMemberSchema,
+  relationship,
+  relationshipSchema,
+  I18N_MESSAGE_FORMATS,
+  i18nLanguages,
+  i18nMessages,
+  i18nBundleVersions,
+  localeSchema,
+  translationsObjectSchema,
+  i18nDirectionSchema,
+  i18nMessageTypeSchema,
+  i18nMessageSourceSchema,
+  i18nMessageFormatSchema,
+  i18nLanguageSchema,
+  i18nMessageSchema,
+  getI18nMessagesQuery,
+  getI18nBundlesQuery,
+  i18nBundleSchema,
+  getI18nBundlesResultSchema,
+  listI18nLanguagesQuery,
+  listI18nMessagesQuery,
+  setDefaultLanguageMutation,
+  batchUpdateMessagesMutation,
+  roles,
+  roleSchema,
+  rolePermissions,
+  rolePermissionSchema,
+  permissions,
+  permissionSchema,
+  ROLE_PERMISSIONS,
+  menus,
+  SYS_INBOX_CODE,
+  menuSchema,
+  getMenuQuery,
+  listMenusQuery,
+  listAllMenusQuery,
+  deleteMenuMutation,
+  toggleMenuVisibilityMutation,
+  createMenuSchema,
+  updateMenuSchema,
+  updateMenuMutation,
+  PLUGIN_MARKETPLACE_STATES,
+  PLUGIN_TRUST_LEVELS,
+  PLUGIN_INSTALL_OPERATIONS,
+  PLUGIN_INSTALL_SOURCES,
+  PLUGIN_INSTALL_JOB_STATUSES,
+  plugins,
+  pluginInstances,
+  pluginCatalogReleases,
+  pluginRegistrySyncState,
+  pluginInstallJobs,
+  pluginConfigs,
+  pluginSchema,
+  pluginInstanceSchema,
+  pluginCatalogReleaseSchema,
+  pluginInstallJobSchema,
+  pluginConfigSchema,
+  listPluginCatalogQuery,
+  installPluginFromRegistryMutation,
+  createPluginUploadMutation,
+  appendPluginUploadMutation,
+  completePluginUploadMutation,
+  getPluginInstallJobQuery,
+  uninstallPluginFromInstanceMutation,
+  rollbackPluginInstallMutation,
+  pluginMigrations,
+  pluginMigrationSchema,
+  ENTITY_EXTENSION_VALUE_TYPES,
+  ENTITY_EXTENSION_PROJECTION_STATUSES,
+  extProjection,
+  ACTION_JOURNAL_STATUSES,
+  ACTION_JOURNAL_ACTIVE_STATUSES,
+  actionExecutionJournal,
+  actionExecutionOutbox,
+  settings,
+  settingSchemas,
+  settingScopeSchema,
+  settingValueTypeSchema,
+  settingSchema,
+  settingSchemaSchema,
+  getSettingQuery,
+  listSettingsQuery,
+  setSettingMutation,
+  deleteSettingMutation,
+  featureFlags,
+  featureFlagOverrides,
+  flagConditionSchema,
+  featureFlagSchema,
+  featureFlagOverrideSchema,
+  checkFeatureFlagQuery,
+  getFeatureFlagQuery,
+  listFeatureFlagsQuery,
+  listFlagOverridesQuery,
+  updateFeatureFlagMutation,
+  deleteFeatureFlagMutation,
+  setFlagOverrideMutation,
+  removeFlagOverrideMutation,
+  media,
+  mediaInsertSchema,
+  mediaSelectSchema,
+  importMediaFromUrlMutation,
+  WEB_PAGE_STATUSES,
+  WEB_DOMAIN_STATUSES,
+  WEB_DOMAIN_CERTIFICATE_STATUSES,
+  WEB_PAGE_RESERVED_PATHS,
+  WEB_PAGE_RESERVED_PREFIXES,
+  webPages,
+  webDomains,
+  webPageSchema,
+  webPageSelectSchema,
+  webDomainSchema,
+  webDomainSelectSchema,
+  webDomainHostnameSchema,
+  webPagePathSchema,
+  webDesignDocumentSchema,
+  createWebPageMutation,
+  updateWebPageMutation,
+  getWebPageDocumentQuery,
+  saveWebPageDocumentMutation,
+  publishWebPageMutation,
+  createWebDomainMutation,
+  getWebDomainQuery,
+  verifyWebDomainMutation,
+  requestWebDomainCertificateMutation,
+  updateWebDomainCertificateStatusMutation,
+  setPrimaryWebDomainMutation,
+  disableWebDomainMutation,
+  deleteWebDomainMutation,
+  WEB_THEME_REVISION_STATUSES,
+  WEB_THEME_SELECTION_STATUSES,
+  webThemeRevisions,
+  webThemeSelections,
+  webThemeHomeTargetSchema,
+  webThemeAdapterSelectionSchema,
+  webThemeAdapterConfigSchema,
+  webThemeRevisionSchema,
+  webThemeRevisionSelectSchema,
+  webThemeSelectionSchema,
+  webThemeSelectionSelectSchema,
+  getWebThemeQuery,
+  setWebThemeEnabledMutation,
+  getWebThemeRevisionQuery,
+  listWebThemeRevisionsQuery,
+  saveWebThemeDraftMutation,
+  activateWebThemeMutation,
+  activateWebThemeRevisionMutation,
+  publishWebThemeDraftMutation,
+  rollbackWebThemeRevisionMutation,
+  issueWebThemePreviewMutation,
+  recoverWebThemeMutation,
+  NotificationTypeEnum,
+  notifications,
+  notificationSchema,
+  notificationTemplates,
+  notificationTemplateSchema,
+  notificationChannels,
+  notificationChannelSchema,
+  notificationPreferences,
+  notificationPreferenceSchema,
+  auditLogs,
+  auditLogSchema,
+  auditEvents,
+  auditEventSchema,
+  auditEventsArchive,
+  auditLogsArchive,
+  auditEventsArchiveSchema,
+  auditLogsArchiveSchema,
+  ScopeType,
+  AccessLevel,
+  entityOwnerships,
+  ownershipAuditLog,
+  entityOwnershipSchema,
+  ownershipAuditLogSchema,
+  capabilities,
+  plans,
+  planItems,
+  userQuotas,
+  wallets,
+  transactions,
+  billingEventOutbox,
+  usageRecords,
+  planSubscriptions,
+  tenantQuotas,
+  capabilitySchema,
+  planSchema,
+  planItemSchema,
+  userQuotaSchema,
+  walletSchema,
+  transactionSchema,
+  billingEventOutboxSchema,
+  usageRecordSchema,
+  planSubscriptionSchema,
+  tenantQuotaSchema,
+  currencies,
+  exchangeRates,
+  currencySchema,
+  exchangeRateSchema,
+  MARKET_REGIONS,
+  geoNameSchema,
+  countryCode2Schema,
+  countryCode3Schema,
+  subdivisionFullCodeSchema,
+  geoCountries,
+  geoSubdivisions,
+  geoCountrySchema,
+  geoSubdivisionSchema,
+  getGeoCountryQuery,
+  listGeoCountriesQuery,
+  getGeoSubdivisionQuery,
+  listGeoSubdivisionsQuery,
+  listMarketRegionsQuery,
+  webhookEndpoints,
+  webhookDeliveries,
+  webhookOutbox,
+  webhookEndpointSchema,
+  webhookDeliverySchema,
+  webhookOutboxSchema,
+  scheduledTasks,
+  taskExecutions,
+  schedulerProviders,
+  scheduledTaskSchema,
+  taskExecutionSchema,
+  schedulerProviderSchema,
+  schema_exports
+};
+//# sourceMappingURL=chunk-3TTVLSF5.js.map