@norbix.ai/react-redux 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2050 @@
+'use strict';
+
+var react$1 = require('@reduxjs/toolkit/query/react');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/createNorbixApi.ts
+
+// src/errors.ts
+function serializeNorbixError(err) {
+  if (err && typeof err === "object") {
+    const e = err;
+    return {
+      status: typeof e.status === "number" ? e.status : 0,
+      code: e.code,
+      message: e.message ?? "Unknown Norbix error",
+      fieldErrors: Array.isArray(e.fieldErrors) ? e.fieldErrors : [],
+      url: e.url
+    };
+  }
+  return {
+    status: 0,
+    message: typeof err === "string" ? err : "Unknown Norbix error",
+    fieldErrors: []
+  };
+}
+
+// src/baseQuery.ts
+function createNorbixBaseQuery(getClient) {
+  return async (call) => {
+    let client;
+    try {
+      client = getClient();
+    } catch (err) {
+      return { error: serializeNorbixError(err) };
+    }
+    if (!client) {
+      return {
+        error: {
+          status: 0,
+          code: "NORBIX_NO_CLIENT",
+          message: "No Norbix client available. Did you forget <NorbixProvider>?",
+          fieldErrors: []
+        }
+      };
+    }
+    try {
+      const data = await call(client);
+      return { data };
+    } catch (err) {
+      return { error: serializeNorbixError(err) };
+    }
+  };
+}
+
+// src/hooks/api/apikeys.ts
+var apiApikeys = (b) => ({
+  getApiKeys: b.query({
+    query: (args) => (norbix) => norbix.api.apikeys.getApiKeys(args),
+    providesTags: [{ type: "ApiKey", id: "LIST" }]
+  }),
+  regenerateApiKeys: b.mutation({
+    query: (args) => (norbix) => norbix.api.apikeys.regenerateApiKeys(args),
+    invalidatesTags: [{ type: "ApiKey", id: "LIST" }]
+  })
+});
+
+// src/hooks/api/auth.ts
+var apiAuth = (b) => ({
+  login: b.mutation({
+    query: (creds) => (norbix) => norbix.login(creds),
+    invalidatesTags: [
+      { type: "MembershipUsers", id: "LIST" },
+      { type: "AccountProfile", id: "CURRENT" },
+      { type: "Account", id: "Profile" }
+    ]
+  }),
+  authenticate: b.mutation({
+    query: (req) => (norbix) => norbix.api.auth.authenticate(req)
+  }),
+  logout: b.mutation({
+    queryFn: async (_arg, _api, _opts, baseQuery) => {
+      const result = await baseQuery((norbix) => {
+        norbix.logout();
+        return Promise.resolve();
+      });
+      if (result.error) return { error: result.error };
+      return { data: void 0 };
+    },
+    invalidatesTags: [
+      { type: "MembershipUsers", id: "LIST" },
+      { type: "AccountProfile", id: "CURRENT" },
+      { type: "Account", id: "Profile" },
+      { type: "DatabaseCollections" },
+      { type: "DatabaseSchemas" }
+    ]
+  })
+});
+
+// src/hooks/api/chat.ts
+var apiChat = (b) => ({
+  askChat: b.mutation({
+    query: (args) => (norbix) => norbix.api.chat.askChat(args)
+  })
+});
+
+// src/hooks/api/database.ts
+var apiDatabase = (b) => ({
+  // ---- Collections — Read ----
+  findCollection: b.query({
+    query: (args) => (norbix) => norbix.api.database.find(args),
+    providesTags: (_res, _err, arg) => [
+      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+    ]
+  }),
+  findOne: b.query({
+    query: (args) => (norbix) => norbix.api.database.findOne(args),
+    providesTags: (_res, _err, arg) => [
+      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+    ]
+  }),
+  countCollection: b.query({
+    query: (args) => (norbix) => norbix.api.database.count(args),
+    providesTags: (_res, _err, arg) => [
+      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+    ]
+  }),
+  distinct: b.query({
+    query: (args) => (norbix) => norbix.api.database.distinct(args),
+    providesTags: (_res, _err, arg) => [
+      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+    ]
+  }),
+  aggregate: b.mutation({
+    query: (args) => (norbix) => norbix.api.database.aggregate(args)
+  }),
+  executeAggregate: b.mutation({
+    query: (args) => (norbix) => norbix.api.database.executeAggregate(args)
+  }),
+  // ---- Collections — Write ----
+  insertOne: b.mutation({
+    query: (args) => (norbix) => norbix.api.database.insertOne(args),
+    invalidatesTags: (_res, _err, arg) => [
+      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+    ]
+  }),
+  insertMany: b.mutation({
+    query: (args) => (norbix) => norbix.api.database.insertMany(args),
+    invalidatesTags: (_res, _err, arg) => [
+      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+    ]
+  }),
+  updateOne: b.mutation({
+    query: (args) => (norbix) => norbix.api.database.updateOne(args),
+    invalidatesTags: (_res, _err, arg) => [
+      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+    ]
+  }),
+  updateMany: b.mutation({
+    query: (args) => (norbix) => norbix.api.database.updateMany(args),
+    invalidatesTags: (_res, _err, arg) => [
+      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+    ]
+  }),
+  replaceOne: b.mutation({
+    query: (args) => (norbix) => norbix.api.database.replaceOne(args),
+    invalidatesTags: (_res, _err, arg) => [
+      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+    ]
+  }),
+  deleteOne: b.mutation({
+    query: (args) => (norbix) => norbix.api.database.deleteOne(args),
+    invalidatesTags: (_res, _err, arg) => [
+      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+    ]
+  }),
+  deleteMany: b.mutation({
+    query: (args) => (norbix) => norbix.api.database.deleteMany(args),
+    invalidatesTags: (_res, _err, arg) => [
+      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+    ]
+  }),
+  changeResponsibility: b.mutation({
+    query: (args) => (norbix) => norbix.api.database.changeResponsibility(args),
+    invalidatesTags: (_res, _err, arg) => [
+      { type: "DatabaseCollections", id: arg?.collectionName ?? "ANY" }
+    ]
+  }),
+  // ---- Taxonomies (read-only on api; admin lives in hub.database) ----
+  findTerms: b.query({
+    query: (args) => (norbix) => norbix.api.database.findTerms(args),
+    providesTags: (_res, _err, arg) => [
+      { type: "DatabaseTaxonomyTerms", id: arg?.taxonomyName ?? "ANY" }
+    ]
+  }),
+  findTermsChildren: b.query({
+    query: (args) => (norbix) => norbix.api.database.findTermsChildren(args),
+    providesTags: (_res, _err, arg) => [
+      { type: "DatabaseTaxonomyTerms", id: arg?.taxonomyName ?? "ANY" }
+    ]
+  }),
+  // Whole term tree of a taxonomy (or a sub-tree from a root term) in one call.
+  findTermTree: b.query({
+    query: (args) => (norbix) => norbix.api.database.findTermTree(args),
+    providesTags: (_res, _err, arg) => [
+      { type: "DatabaseTaxonomyTerms", id: arg?.taxonomyName ?? "ANY" }
+    ]
+  }),
+  // Single-parent taxonomy structure tree (Countries → Cities), optionally with terms.
+  findTaxonomyTree: b.query({
+    query: (args) => (norbix) => norbix.api.database.findTaxonomyTree(args),
+    providesTags: () => [{ type: "DatabaseTaxonomyTerms", id: "ANY" }]
+  }),
+  // ---- Schemas (read-only mirror; full CRUD lives in hub.database) ----
+  getApiDatabaseSchema: b.query({
+    query: (args) => (norbix) => norbix.api.database.getDatabaseSchema(args),
+    providesTags: (_res, _err, arg) => [
+      { type: "DatabaseSchemas", id: arg?.id ?? "CURRENT" }
+    ]
+  }),
+  getApiDatabaseSchemas: b.query({
+    query: (args) => (norbix) => norbix.api.database.getDatabaseSchemas(args),
+    providesTags: [{ type: "DatabaseSchemas", id: "LIST" }]
+  })
+});
+
+// src/hooks/api/files.ts
+var apiFiles = (b) => ({
+  commitUpload: b.mutation({
+    query: (args) => (norbix) => norbix.api.files.commitUpload(args),
+    invalidatesTags: ["Files"]
+  }),
+  deleteFileApi: b.mutation({
+    query: (args) => (norbix) => norbix.api.files.deleteFileApi(args),
+    invalidatesTags: ["Files"]
+  }),
+  deleteManyFilesApi: b.mutation({
+    query: (args) => (norbix) => norbix.api.files.deleteManyFilesApi(args),
+    invalidatesTags: ["Files"]
+  }),
+  downloadFileApi: b.query({
+    query: (args) => (norbix) => norbix.api.files.downloadFileApi(args),
+    providesTags: ["Files"]
+  }),
+  getFileInfo: b.query({
+    query: (args) => (norbix) => norbix.api.files.getFileInfo(args),
+    providesTags: ["Files"]
+  }),
+  getSignedUrl: b.query({
+    query: (args) => (norbix) => norbix.api.files.getSignedUrl(args),
+    providesTags: ["Files"]
+  }),
+  listFiles: b.query({
+    query: (args) => (norbix) => norbix.api.files.listFiles(args),
+    providesTags: ["Files"]
+  }),
+  requestUploadUrl: b.mutation({
+    query: (args) => (norbix) => norbix.api.files.requestUploadUrl(args),
+    invalidatesTags: ["Files"]
+  }),
+  /**
+   * Reads a file somebody published from the Hub side. The one Files call
+   * that carries no credentials at all — the link has to work in an e-mail,
+   * in an `<img src>`, or in a browser on a stranger's phone.
+   *
+   * Answers with the file's raw bytes (`Uint8Array`), not JSON.
+   *
+   * Cached under its own `id` rather than the plain `Files` tag: the bytes
+   * belong to the public link, and are keyed by the id + name a caller asked
+   * for. Making the file private again invalidates `Files`, which is a
+   * different tag, so a stale cache entry here is possible — call
+   * `refetch()` when that matters to you.
+   */
+  getPublicFile: b.query({
+    query: (args) => (norbix) => norbix.api.files.getPublicFile(args),
+    providesTags: (_res, _err, arg) => [
+      { type: "Files", id: `PUBLIC:${arg?.publicId ?? "unknown"}` }
+    ]
+  })
+});
+
+// src/hooks/api/membership.ts
+var apiMembership = (b) => ({
+  blockUser: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.blockUser(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  saveSystemUserWithPermissions: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.saveSystemUserWithPermissions(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  saveGuestUser: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.saveGuestUser(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  saveUserNameUser: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.saveUserNameUser(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  saveEmailUser: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.saveEmailUser(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  savePhoneUser: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.savePhoneUser(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  savePhoneUserNameWithPermissions: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.savePhoneUserNameWithPermissions(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  saveEmailUserNameWithPermissions: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.saveEmailUserNameWithPermissions(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  saveUserNameWithPermissions: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.saveUserNameWithPermissions(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  deleteUser: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.deleteUser(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  getUser: b.query({
+    query: (args) => (norbix) => norbix.api.membership.getUser(args),
+    providesTags: ["MembershipUsers"]
+  }),
+  getUsers: b.query({
+    query: (args) => (norbix) => norbix.api.membership.getUsers(args),
+    providesTags: ["MembershipUsers"]
+  }),
+  getUserPreferences: b.query({
+    query: (args) => (norbix) => norbix.api.membership.getUserPreferences(args),
+    providesTags: ["MembershipUsers"]
+  }),
+  inviteUser: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.inviteUser(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  linkIdentity: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.linkIdentity(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  assignRolePermissions: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.assignRolePermissions(args),
+    invalidatesTags: ["MembershipRoles"]
+  }),
+  unblockUser: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.unblockUser(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  updateUser: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.updateUser(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  updateUserPreferences: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.updateUserPreferences(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  passkeyAuthenticationOptions: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.passkeyAuthenticationOptions(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  verifyPasskeyAuthentication: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.verifyPasskeyAuthentication(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  listPasskeys: b.query({
+    query: (args) => (norbix) => norbix.api.membership.listPasskeys(args),
+    providesTags: ["MembershipUsers"]
+  }),
+  renamePasskey: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.renamePasskey(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  revokePasskey: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.revokePasskey(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  useRecoveryCode: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.useRecoveryCode(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  requestMagicLink: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.requestMagicLink(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  consumeMagicLink: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.consumeMagicLink(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  hasPasskey: b.query({
+    query: (args) => (norbix) => norbix.api.membership.hasPasskey(args),
+    providesTags: ["MembershipUsers"]
+  }),
+  startEmailVerification: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.startEmailVerification(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  confirmEmailVerification: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.confirmEmailVerification(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  passkeyRegistrationOptions: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.passkeyRegistrationOptions(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  verifyPasskeyRegistration: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.verifyPasskeyRegistration(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  refreshPasskeyToken: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.refreshPasskeyToken(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  passkeyLogout: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.passkeyLogout(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  // ---- password (change + reset) -------------------------------------
+  changePassword: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.changePassword(args)
+  }),
+  requestPasswordReset: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.requestPasswordReset(args)
+  }),
+  confirmPasswordReset: b.mutation({
+    query: (args) => (norbix) => norbix.api.membership.confirmPasswordReset(args)
+  })
+});
+
+// src/hooks/api/public.ts
+var apiPublic = (b) => ({
+  getPublicProjectConfig: b.query({
+    query: (args) => (norbix) => norbix.api.public.getPublicProjectConfig(args),
+    providesTags: [{ type: "Config", id: "PUBLIC" }]
+  }),
+  getPublicProjectLegal: b.query({
+    query: (args) => (norbix) => norbix.api.public.getPublicProjectLegal(args),
+    providesTags: (_res, _err, arg) => [
+      { type: "Config", id: `LEGAL:${arg?.kind ?? "unknown"}` }
+    ]
+  })
+});
+
+// src/hooks/hub/account.ts
+var hubAccount = (b) => ({
+  getAccountProfile: b.query({
+    query: (args) => (norbix) => norbix.hub.account.getAccountProfile(args),
+    providesTags: ["Account"]
+  }),
+  updateAccountProfile: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.updateAccountProfile(args),
+    invalidatesTags: ["Account"]
+  }),
+  resendAccountVerificationToken: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.resendAccountVerificationToken(args),
+    invalidatesTags: ["Account"]
+  }),
+  getAccountStatus: b.query({
+    query: (args) => (norbix) => norbix.hub.account.getAccountStatus(args),
+    providesTags: ["Account"]
+  }),
+  createStripeCheckoutSession: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.createStripeCheckoutSession(args),
+    invalidatesTags: ["Billing"]
+  }),
+  getStripeBillingPortalUrl: b.query({
+    query: (args) => (norbix) => norbix.hub.account.getStripeBillingPortalUrl(args),
+    providesTags: ["Billing"]
+  }),
+  createTeamMemberFromInvitation: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.createTeamMemberFromInvitation(args),
+    invalidatesTags: ["Account"]
+  }),
+  verifyAccount: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.verifyAccount(args),
+    invalidatesTags: ["Account"]
+  }),
+  deleteNotificationsGroup: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.deleteNotificationsGroup(args),
+    invalidatesTags: ["Account"]
+  }),
+  deleteNotificationsTag: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.deleteNotificationsTag(args),
+    invalidatesTags: ["Account"]
+  }),
+  removeTagFromNotificationsGroup: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.removeTagFromNotificationsGroup(args),
+    invalidatesTags: ["Account"]
+  }),
+  saveNotificationsGroup: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.saveNotificationsGroup(args),
+    invalidatesTags: ["Account"]
+  }),
+  saveNotificationsTag: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.saveNotificationsTag(args),
+    invalidatesTags: ["Account"]
+  }),
+  createProject: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.createProject(args),
+    invalidatesTags: ["Projects"]
+  }),
+  deleteProject: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.deleteProject(args),
+    invalidatesTags: ["Projects"]
+  }),
+  getProject: b.query({
+    query: (args) => (norbix) => norbix.hub.account.getProject(args),
+    providesTags: ["Projects"]
+  }),
+  getProjects: b.query({
+    query: (args) => (norbix) => norbix.hub.account.getProjects(args),
+    providesTags: ["Projects"]
+  }),
+  getAccountRegions: b.query({
+    query: (args) => (norbix) => norbix.hub.account.getAccountRegions(args),
+    providesTags: ["Account"]
+  }),
+  getProjectTokens: b.query({
+    query: (args) => (norbix) => norbix.hub.account.getProjectTokens(args),
+    providesTags: ["Projects"]
+  }),
+  updateProjectAccentColor: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.updateProjectAccentColor(args),
+    invalidatesTags: ["Projects"]
+  }),
+  updateProjectIcon: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.updateProjectIcon(args),
+    invalidatesTags: ["Projects"]
+  }),
+  updateProjectLogo: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.updateProjectLogo(args),
+    invalidatesTags: ["Projects"]
+  }),
+  updateProjectMainColor: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.updateProjectMainColor(args),
+    invalidatesTags: ["Projects"]
+  }),
+  updateProjectAllowedOrigins: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.updateProjectAllowedOrigins(args),
+    invalidatesTags: ["Projects"]
+  }),
+  updateProjectDefaultLanguage: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.updateProjectDefaultLanguage(args),
+    invalidatesTags: ["Projects"]
+  }),
+  updateProjectDescription: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.updateProjectDescription(args),
+    invalidatesTags: ["Projects"]
+  }),
+  disableProject: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.disableProject(args),
+    invalidatesTags: ["Projects"]
+  }),
+  enableProject: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.enableProject(args),
+    invalidatesTags: ["Projects"]
+  }),
+  updateProjectLanguages: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.updateProjectLanguages(args),
+    invalidatesTags: ["Projects"]
+  }),
+  updateProjectUrl: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.updateProjectUrl(args),
+    invalidatesTags: ["Projects"]
+  }),
+  updateProjectName: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.updateProjectName(args),
+    invalidatesTags: ["Projects"]
+  }),
+  updateProjectRegions: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.updateProjectRegions(args),
+    invalidatesTags: ["Projects"]
+  }),
+  createAccount: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.createAccount(args),
+    invalidatesTags: ["Account"]
+  }),
+  getAccountCollaborators: b.query({
+    query: (args) => (norbix) => norbix.hub.account.getAccountCollaborators(args),
+    providesTags: ["Account"]
+  }),
+  sendInviteToTeamMember: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.sendInviteToTeamMember(args),
+    invalidatesTags: ["Account"]
+  }),
+  getLicenses: b.query({
+    query: (args) => (norbix) => norbix.hub.account.getLicenses(args),
+    providesTags: ["Billing"]
+  }),
+  askAccountChat: b.mutation({
+    query: (args) => (norbix) => norbix.hub.account.askChat(args),
+    invalidatesTags: ["Account"]
+  })
+});
+
+// src/hooks/hub/ai.ts
+var hubAi = (b) => ({
+  deleteLlmIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.ai.deleteLlmIntegration(args),
+    invalidatesTags: ["Ai"]
+  }),
+  disableLlmIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.ai.disableLlmIntegration(args),
+    invalidatesTags: ["Ai"]
+  }),
+  enableLlmIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.ai.enableLlmIntegration(args),
+    invalidatesTags: ["Ai"]
+  }),
+  getLlmIntegration: b.query({
+    query: (args) => (norbix) => norbix.hub.ai.getLlmIntegration(args),
+    providesTags: ["Ai"]
+  }),
+  getLlmIntegrations: b.query({
+    query: (args) => (norbix) => norbix.hub.ai.getLlmIntegrations(args),
+    providesTags: ["Ai"]
+  }),
+  saveLlmIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.ai.saveLlmIntegration(args),
+    invalidatesTags: ["Ai"]
+  }),
+  testLlmIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.ai.testLlmIntegration(args),
+    invalidatesTags: ["Ai"]
+  }),
+  deleteMcpIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.ai.deleteMcpIntegration(args),
+    invalidatesTags: ["Ai"]
+  }),
+  disableMcpIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.ai.disableMcpIntegration(args),
+    invalidatesTags: ["Ai"]
+  }),
+  enableMcpIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.ai.enableMcpIntegration(args),
+    invalidatesTags: ["Ai"]
+  }),
+  getMcpIntegration: b.query({
+    query: (args) => (norbix) => norbix.hub.ai.getMcpIntegration(args),
+    providesTags: ["Ai"]
+  }),
+  getMcpIntegrations: b.query({
+    query: (args) => (norbix) => norbix.hub.ai.getMcpIntegrations(args),
+    providesTags: ["Ai"]
+  }),
+  saveMcpIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.ai.saveMcpIntegration(args),
+    invalidatesTags: ["Ai"]
+  }),
+  testMcpIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.ai.testMcpIntegration(args),
+    invalidatesTags: ["Ai"]
+  })
+});
+
+// src/hooks/hub/apikeys.ts
+var hubApikeys = (b) => ({
+  getHubApiKeys: b.query({
+    query: (args) => (norbix) => norbix.hub.apikeys.getApiKeys(args),
+    providesTags: ["ApiKey"]
+  }),
+  regenerateHubApiKeys: b.mutation({
+    query: (args) => (norbix) => norbix.hub.apikeys.regenerateApiKeys(args),
+    invalidatesTags: ["ApiKey"]
+  })
+});
+
+// src/hooks/hub/database.ts
+var hubDatabase = (b) => ({
+  disableDatabase: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.disableDatabase(args),
+    invalidatesTags: ["Database"]
+  }),
+  enableDatabase: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.enableDatabase(args),
+    invalidatesTags: ["Database"]
+  }),
+  deleteSchemaTrigger: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.deleteSchemaTrigger(args),
+    invalidatesTags: ["Triggers"]
+  }),
+  disableSchemaTrigger: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.disableSchemaTrigger(args),
+    invalidatesTags: ["Triggers"]
+  }),
+  enableSchemaTrigger: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.enableSchemaTrigger(args),
+    invalidatesTags: ["Triggers"]
+  }),
+  getSchemaTrigger: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getSchemaTrigger(args),
+    providesTags: ["Triggers"]
+  }),
+  getSchemaTriggers: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getSchemaTriggers(args),
+    providesTags: ["Triggers"]
+  }),
+  saveSchemaTrigger: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.saveSchemaTrigger(args),
+    invalidatesTags: ["Triggers"]
+  }),
+  deleteDatabaseTaxonomy: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.deleteDatabaseTaxonomy(args),
+    invalidatesTags: ["DatabaseTaxonomies"]
+  }),
+  getDatabaseTaxonomy: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getDatabaseTaxonomy(args),
+    providesTags: ["DatabaseTaxonomies"]
+  }),
+  getDatabaseTaxonomies: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getDatabaseTaxonomies(args),
+    providesTags: ["Database"]
+  }),
+  saveDatabaseTaxonomy: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.saveDatabaseTaxonomy(args),
+    invalidatesTags: ["DatabaseTaxonomies"]
+  }),
+  deleteDatabaseTaxonomyTerm: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.deleteDatabaseTaxonomyTerm(args),
+    invalidatesTags: ["DatabaseTaxonomyTerms"]
+  }),
+  deleteManyDatabaseTaxonomyTerms: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.deleteManyDatabaseTaxonomyTerms(args),
+    invalidatesTags: ["DatabaseTaxonomyTerms"]
+  }),
+  getDatabaseTaxonomyTerm: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getDatabaseTaxonomyTerm(args),
+    providesTags: ["DatabaseTaxonomyTerms"]
+  }),
+  saveDatabaseTaxonomyTerm: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.saveDatabaseTaxonomyTerm(args),
+    invalidatesTags: ["DatabaseTaxonomyTerms"]
+  }),
+  updateDatabaseTaxonomyTerm: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.updateDatabaseTaxonomyTerm(args),
+    invalidatesTags: ["DatabaseTaxonomyTerms"]
+  }),
+  deleteDatabaseSchema: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.deleteDatabaseSchema(args),
+    invalidatesTags: ["DatabaseSchemas"]
+  }),
+  discardDatabaseSchemaDraft: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.discardDatabaseSchemaDraft(args),
+    invalidatesTags: ["DatabaseSchemas"]
+  }),
+  getDatabaseSchema: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getDatabaseSchema(args),
+    providesTags: ["DatabaseSchemas"]
+  }),
+  getDatabaseSchemas: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getDatabaseSchemas(args),
+    providesTags: ["DatabaseSchemas"]
+  }),
+  getDatabaseSchemaDraft: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getDatabaseSchemaDraft(args),
+    providesTags: ["DatabaseSchemas"]
+  }),
+  getDatabaseSchemaVersionDiff: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getDatabaseSchemaVersionDiff(args),
+    providesTags: ["DatabaseSchemas"]
+  }),
+  getDatabaseSchemaVersions: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getDatabaseSchemaVersions(args),
+    providesTags: ["DatabaseSchemas"]
+  }),
+  publishDatabaseSchema: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.publishDatabaseSchema(args),
+    invalidatesTags: ["DatabaseSchemas"]
+  }),
+  renameDatabaseSchema: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.renameDatabaseSchema(args),
+    invalidatesTags: ["DatabaseSchemas"]
+  }),
+  saveDatabaseSchema: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.saveDatabaseSchema(args),
+    invalidatesTags: ["DatabaseSchemas"]
+  }),
+  updateDatabaseSchemaDraft: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.updateDatabaseSchemaDraft(args),
+    invalidatesTags: ["DatabaseSchemas"]
+  }),
+  updateDatabaseSchemaSettings: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.updateDatabaseSchemaSettings(args),
+    invalidatesTags: ["DatabaseSchemas"]
+  }),
+  deleteDatabaseIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.deleteDatabaseIntegration(args),
+    invalidatesTags: ["DatabaseIntegrations"]
+  }),
+  disableDatabaseIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.disableDatabaseIntegration(args),
+    invalidatesTags: ["DatabaseIntegrations"]
+  }),
+  enableDatabaseIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.enableDatabaseIntegration(args),
+    invalidatesTags: ["DatabaseIntegrations"]
+  }),
+  getDatabaseIntegration: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getDatabaseIntegration(args),
+    providesTags: ["DatabaseIntegrations"]
+  }),
+  getDatabaseIntegrations: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getDatabaseIntegrations(args),
+    providesTags: ["DatabaseIntegrations"]
+  }),
+  getAllowedFlexTiers: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getAllowedFlexTiers(args),
+    providesTags: ["DatabaseIntegrations"]
+  }),
+  revealManagedFlexConnectionString: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.revealManagedFlexConnectionString(args),
+    invalidatesTags: ["DatabaseIntegrations"]
+  }),
+  saveDatabaseIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.saveDatabaseIntegration(args),
+    invalidatesTags: ["DatabaseIntegrations"]
+  }),
+  setDatabaseIntegrationAsDefault: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.setDatabaseIntegrationAsDefault(args),
+    invalidatesTags: ["DatabaseIntegrations"]
+  }),
+  testDatabaseIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.testDatabaseIntegration(args),
+    invalidatesTags: ["DatabaseIntegrations"]
+  }),
+  deleteDatabaseAggregate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.deleteDatabaseAggregate(args),
+    invalidatesTags: ["DatabaseAggregates"]
+  }),
+  getDatabaseAggregate: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getDatabaseAggregate(args),
+    providesTags: ["DatabaseAggregates"]
+  }),
+  getDatabaseAggregates: b.query({
+    query: (args) => (norbix) => norbix.hub.database.getDatabaseAggregates(args),
+    providesTags: ["DatabaseAggregates"]
+  }),
+  saveDatabaseAggregate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.saveDatabaseAggregate(args),
+    invalidatesTags: ["DatabaseAggregates"]
+  }),
+  testDatabaseAggregate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.database.testDatabaseAggregate(args),
+    invalidatesTags: ["DatabaseAggregates"]
+  })
+});
+
+// src/hooks/hub/email.ts
+var hubEmail = (b) => ({
+  oneClickUnsubscribe: b.mutation({
+    query: (args) => (norbix) => norbix.hub.email.oneClickUnsubscribe(args)
+  })
+});
+
+// src/hooks/hub/environments.ts
+var hubEnvironments = (b) => ({
+  listEnvironments: b.query({
+    query: (args) => (norbix) => norbix.hub.environments.list(args),
+    providesTags: ["Environments"]
+  }),
+  createEnvironment: b.mutation({
+    query: (args) => (norbix) => norbix.hub.environments.create(args),
+    // Creating an env changes the available set and seeds a DB integration.
+    invalidatesTags: ["Environments", "Projects", "DatabaseIntegrations"]
+  }),
+  deleteEnvironment: b.mutation({
+    query: (args) => (norbix) => norbix.hub.environments.delete(args),
+    // Deleting cascades integrations across modules in that env.
+    invalidatesTags: ["Environments", "Projects", "DatabaseIntegrations"]
+  })
+});
+
+// src/hooks/hub/files.ts
+var hubFiles = (b) => ({
+  disableFiles: b.mutation({
+    query: (args) => (norbix) => norbix.hub.files.disableFiles(args),
+    invalidatesTags: ["Files"]
+  }),
+  enableFiles: b.mutation({
+    query: (args) => (norbix) => norbix.hub.files.enableFiles(args),
+    invalidatesTags: ["Files"]
+  }),
+  deleteFilesTrigger: b.mutation({
+    query: (args) => (norbix) => norbix.hub.files.deleteFilesTrigger(args),
+    invalidatesTags: ["Triggers"]
+  }),
+  disableFilesTrigger: b.mutation({
+    query: (args) => (norbix) => norbix.hub.files.disableFilesTrigger(args),
+    invalidatesTags: ["Triggers"]
+  }),
+  enableFilesTrigger: b.mutation({
+    query: (args) => (norbix) => norbix.hub.files.enableFilesTrigger(args),
+    invalidatesTags: ["Triggers"]
+  }),
+  getFilesTrigger: b.query({
+    query: (args) => (norbix) => norbix.hub.files.getFilesTrigger(args),
+    providesTags: ["Triggers"]
+  }),
+  getFilesTriggers: b.query({
+    query: (args) => (norbix) => norbix.hub.files.getFilesTriggers(args),
+    providesTags: ["Triggers"]
+  }),
+  saveFilesTrigger: b.mutation({
+    query: (args) => (norbix) => norbix.hub.files.saveFilesTrigger(args),
+    invalidatesTags: ["Triggers"]
+  }),
+  deleteFilesIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.files.deleteFilesIntegration(args),
+    invalidatesTags: ["FilesIntegrations"]
+  }),
+  disableFilesIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.files.disableFilesIntegration(args),
+    invalidatesTags: ["FilesIntegrations"]
+  }),
+  enableFilesIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.files.enableFilesIntegration(args),
+    invalidatesTags: ["FilesIntegrations"]
+  }),
+  getFilesIntegration: b.query({
+    query: (args) => (norbix) => norbix.hub.files.getFilesIntegration(args),
+    providesTags: ["FilesIntegrations"]
+  }),
+  getFilesIntegrations: b.query({
+    query: (args) => (norbix) => norbix.hub.files.getFilesIntegrations(args),
+    providesTags: ["FilesIntegrations"]
+  }),
+  saveFilesIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.files.saveFilesIntegration(args),
+    invalidatesTags: ["FilesIntegrations"]
+  }),
+  setFilesIntegrationAsDefault: b.mutation({
+    query: (args) => (norbix) => norbix.hub.files.setFilesIntegrationAsDefault(args),
+    invalidatesTags: ["FilesIntegrations"]
+  }),
+  getFile: b.query({
+    query: (args) => (norbix) => norbix.hub.files.getFile(args),
+    providesTags: ["Files"]
+  }),
+  getFolderFiles: b.query({
+    query: (args) => (norbix) => norbix.hub.files.getFolderFiles(args),
+    providesTags: ["Files"]
+  }),
+  /**
+   * Tries an integration's credentials against the storage provider and
+   * answers whether they work. Nothing is saved, so nothing is invalidated —
+   * call it before `saveFilesIntegration` to tell a bad key from a bad
+   * bucket. A mutation rather than a query because it is an action with a
+   * side effect on the provider, and its answer must never be served from
+   * cache.
+   */
+  testFilesIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.files.testFilesIntegration(args)
+  }),
+  /**
+   * Makes one file readable by anyone holding its link. Answers with the
+   * `nbpf_…` public id; the link itself arrives on the file's `publicUrl`
+   * the next time the listing is read — which is why this invalidates
+   * `Files`.
+   */
+  makeFilePublic: b.mutation({
+    query: (args) => (norbix) => norbix.hub.files.makeFilePublic(args),
+    invalidatesTags: ["Files"]
+  }),
+  /**
+   * Takes a file's public link away. Refused while a folder above the file
+   * is public — switch the folder off instead.
+   */
+  makeFilePrivate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.files.makeFilePrivate(args),
+    invalidatesTags: ["Files"]
+  }),
+  /**
+   * Publishes a whole folder prefix — one record, however many files sit
+   * under it, at any depth. Every file underneath changes its `isPublic`,
+   * so the whole `Files` tag goes.
+   */
+  makeFolderPublic: b.mutation({
+    query: (args) => (norbix) => norbix.hub.files.makeFolderPublic(args),
+    invalidatesTags: ["Files"]
+  }),
+  /** Takes back every link inside the folder, including per-file ones. */
+  makeFolderPrivate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.files.makeFolderPrivate(args),
+    invalidatesTags: ["Files"]
+  })
+});
+
+// src/hooks/hub/logs.ts
+var hubLogs = (b) => ({
+  disableLogging: b.mutation({
+    query: (args) => (norbix) => norbix.hub.logs.disableLogging(args),
+    invalidatesTags: ["Logs"]
+  }),
+  enableLogging: b.mutation({
+    query: (args) => (norbix) => norbix.hub.logs.enableLogging(args),
+    invalidatesTags: ["Logs"]
+  }),
+  deleteLoggingIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.logs.deleteLoggingIntegration(args),
+    invalidatesTags: ["LogsIntegrations"]
+  }),
+  disableLoggingIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.logs.disableLoggingIntegration(args),
+    invalidatesTags: ["LogsIntegrations"]
+  }),
+  enableLoggingIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.logs.enableLoggingIntegration(args),
+    invalidatesTags: ["LogsIntegrations"]
+  }),
+  getLoggingIntegration: b.query({
+    query: (args) => (norbix) => norbix.hub.logs.getLoggingIntegration(args),
+    providesTags: ["LogsIntegrations"]
+  }),
+  getLoggingIntegrations: b.query({
+    query: (args) => (norbix) => norbix.hub.logs.getLoggingIntegrations(args),
+    providesTags: ["LogsIntegrations"]
+  }),
+  saveLoggingIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.logs.saveLoggingIntegration(args),
+    invalidatesTags: ["LogsIntegrations"]
+  }),
+  testLoggingIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.logs.testLoggingIntegration(args),
+    invalidatesTags: ["LogsIntegrations"]
+  }),
+  getLogsByCorrelationId: b.query({
+    query: (args) => (norbix) => norbix.hub.logs.getLogsByCorrelationId(args),
+    providesTags: ["Logs"]
+  })
+});
+
+// src/hooks/hub/membership.ts
+var hubMembership = (b) => ({
+  disableMembership: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.disableMembership(args),
+    invalidatesTags: ["Membership"]
+  }),
+  enableMembership: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.enableMembership(args),
+    invalidatesTags: ["Membership"]
+  }),
+  deleteMembershipTrigger: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.deleteMembershipTrigger(args),
+    invalidatesTags: ["Triggers"]
+  }),
+  disableMembershipTrigger: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.disableMembershipTrigger(args),
+    invalidatesTags: ["Triggers"]
+  }),
+  enableMembershipTrigger: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.enableMembershipTrigger(args),
+    invalidatesTags: ["Triggers"]
+  }),
+  getMembershipTrigger: b.query({
+    query: (args) => (norbix) => norbix.hub.membership.getMembershipTrigger(args),
+    providesTags: ["Triggers"]
+  }),
+  getMembershipTriggers: b.query({
+    query: (args) => (norbix) => norbix.hub.membership.getMembershipTriggers(args),
+    providesTags: ["Triggers"]
+  }),
+  saveMembershipTrigger: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.saveMembershipTrigger(args),
+    invalidatesTags: ["Triggers"]
+  }),
+  createRole: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.createRole(args),
+    invalidatesTags: ["MembershipRoles"]
+  }),
+  deleteRole: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.deleteRole(args),
+    invalidatesTags: ["MembershipRoles"]
+  }),
+  getRole: b.query({
+    query: (args) => (norbix) => norbix.hub.membership.getRole(args),
+    providesTags: ["MembershipRoles"]
+  }),
+  getRoles: b.query({
+    query: (args) => (norbix) => norbix.hub.membership.getRoles(args),
+    providesTags: ["MembershipRoles"]
+  }),
+  updateRolePolicies: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.updateRolePolicies(args),
+    invalidatesTags: ["MembershipRoles"]
+  }),
+  createPolicy: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.createPolicy(args),
+    invalidatesTags: ["MembershipPolicies"]
+  }),
+  deletePolicy: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.deletePolicy(args),
+    invalidatesTags: ["MembershipPolicies"]
+  }),
+  getPolicy: b.query({
+    query: (args) => (norbix) => norbix.hub.membership.getPolicy(args),
+    providesTags: ["MembershipPolicies"]
+  }),
+  getPolicies: b.query({
+    query: (args) => (norbix) => norbix.hub.membership.getPolicies(args),
+    providesTags: ["MembershipPolicies"]
+  }),
+  updatePolicy: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.updatePolicy(args),
+    invalidatesTags: ["MembershipPolicies"]
+  }),
+  getPasskeySettings: b.query({
+    query: (args) => (norbix) => norbix.hub.membership.getPasskeySettings(args),
+    providesTags: ["MembershipUsers"]
+  }),
+  savePasskeySettings: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.savePasskeySettings(args),
+    invalidatesTags: ["MembershipUsers"]
+  }),
+  deleteMembershipIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.deleteMembershipIntegration(args),
+    invalidatesTags: ["MembershipIntegrations"]
+  }),
+  disableMembershipIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.disableMembershipIntegration(args),
+    invalidatesTags: ["MembershipIntegrations"]
+  }),
+  enableMembershipIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.enableMembershipIntegration(args),
+    invalidatesTags: ["MembershipIntegrations"]
+  }),
+  getMembershipIntegration: b.query({
+    query: (args) => (norbix) => norbix.hub.membership.getMembershipIntegration(args),
+    providesTags: ["MembershipIntegrations"]
+  }),
+  getMembershipIntegrations: b.query({
+    query: (args) => (norbix) => norbix.hub.membership.getMembershipIntegrations(args),
+    providesTags: ["MembershipIntegrations"]
+  }),
+  saveMembershipIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.saveMembershipIntegration(args),
+    invalidatesTags: ["MembershipIntegrations"]
+  }),
+  setMembershipIntegrationAsDefault: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.setMembershipIntegrationAsDefault(args),
+    invalidatesTags: ["MembershipIntegrations"]
+  })
+});
+
+// src/hooks/hub/notifications.ts
+var hubNotifications = (b) => ({
+  getUserNotificationPreferences: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getUserNotificationPreferences(args),
+    providesTags: ["Account"]
+  }),
+  updateUserNotificationsPreferences: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.updateUserNotificationsPreferences(args),
+    invalidatesTags: ["Emails"]
+  }),
+  disableEmail: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.disableEmail(args),
+    invalidatesTags: ["Emails"]
+  }),
+  enableEmail: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.enableEmail(args),
+    invalidatesTags: ["Emails"]
+  }),
+  saveEmailValidationIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.saveEmailValidationIntegration(args),
+    invalidatesTags: ["EmailIntegrations"]
+  }),
+  testEmailValidationIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.testEmailValidationIntegration(args),
+    invalidatesTags: ["EmailIntegrations"]
+  }),
+  attachFileToTemplate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.attachFileToTemplate(args),
+    invalidatesTags: ["Emails"]
+  }),
+  createEmailTemplate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.createEmailTemplate(args),
+    invalidatesTags: ["EmailTemplates"]
+  }),
+  deleteEmailTemplate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.deleteEmailTemplate(args),
+    invalidatesTags: ["EmailTemplates"]
+  }),
+  getEmailTemplate: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getEmailTemplate(args),
+    providesTags: ["EmailTemplates"]
+  }),
+  getEmailTemplates: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getEmailTemplates(args),
+    providesTags: ["EmailTemplates"]
+  }),
+  getMjml: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getMjml(args),
+    providesTags: ["Emails"]
+  }),
+  getSystemEmailTemplate: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getSystemEmailTemplate(args),
+    providesTags: ["EmailTemplates"]
+  }),
+  getSystemEmailTemplates: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getSystemEmailTemplates(args),
+    providesTags: ["EmailTemplates"]
+  }),
+  getEmailTemplateAvailableTokens: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getEmailTemplateAvailableTokens(args),
+    providesTags: ["EmailTemplates"]
+  }),
+  updateEmailTemplate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.updateEmailTemplate(args),
+    invalidatesTags: ["EmailTemplates"]
+  }),
+  deleteEmailSignature: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.deleteEmailSignature(args),
+    invalidatesTags: ["EmailSignatures"]
+  }),
+  getEmailSignature: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getEmailSignature(args),
+    providesTags: ["EmailSignatures"]
+  }),
+  getEmailSignatures: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getEmailSignatures(args),
+    providesTags: ["EmailSignatures"]
+  }),
+  saveEmailSignature: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.saveEmailSignature(args),
+    invalidatesTags: ["EmailSignatures"]
+  }),
+  getEmailSettings: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getEmailSettings(args),
+    providesTags: ["EmailSettings"]
+  }),
+  confirmEmailIntegrationHumanDelivery: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.confirmEmailIntegrationHumanDelivery(args),
+    invalidatesTags: ["EmailIntegrations"]
+  }),
+  deleteEmailIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.deleteEmailIntegration(args),
+    invalidatesTags: ["EmailIntegrations"]
+  }),
+  disableEmailIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.disableEmailIntegration(args),
+    invalidatesTags: ["EmailIntegrations"]
+  }),
+  enableEmailIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.enableEmailIntegration(args),
+    invalidatesTags: ["EmailIntegrations"]
+  }),
+  getEmailIntegration: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getEmailIntegration(args),
+    providesTags: ["EmailIntegrations"]
+  }),
+  getEmailIntegrations: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getEmailIntegrations(args),
+    providesTags: ["EmailIntegrations"]
+  }),
+  saveEmailIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.saveEmailIntegration(args),
+    invalidatesTags: ["EmailIntegrations"]
+  }),
+  setEmailsIntegrationAsDefault: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.setEmailsIntegrationAsDefault(args),
+    invalidatesTags: ["Emails"]
+  }),
+  testEmailIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.testEmailIntegration(args),
+    invalidatesTags: ["EmailIntegrations"]
+  }),
+  archiveEmailTemplate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.archiveEmailTemplate(args),
+    invalidatesTags: ["EmailTemplates"]
+  }),
+  cloneEmailTemplate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.cloneEmailTemplate(args),
+    invalidatesTags: ["EmailTemplates"]
+  }),
+  unArchiveEmailTemplate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.unArchiveEmailTemplate(args),
+    invalidatesTags: ["EmailTemplates"]
+  }),
+  deleteEmailFooter: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.deleteEmailFooter(args),
+    invalidatesTags: ["EmailFooters"]
+  }),
+  getEmailFooter: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getEmailFooter(args),
+    providesTags: ["EmailFooters"]
+  }),
+  getEmailFooters: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getEmailFooters(args),
+    providesTags: ["EmailFooters"]
+  }),
+  saveEmailFooter: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.saveEmailFooter(args),
+    invalidatesTags: ["EmailFooters"]
+  }),
+  createEmailCampaign: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.createEmailCampaign(args),
+    invalidatesTags: ["EmailCampaigns"]
+  }),
+  deleteEmailCampaign: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.deleteEmailCampaign(args),
+    invalidatesTags: ["EmailCampaigns"]
+  }),
+  getEmailCampaign: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getEmailCampaign(args),
+    providesTags: ["EmailCampaigns"]
+  }),
+  getEmailCampaigns: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getEmailCampaigns(args),
+    providesTags: ["EmailCampaigns"]
+  }),
+  getEmailCampaignBatches: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getEmailCampaignBatches(args),
+    providesTags: ["EmailCampaigns"]
+  }),
+  getEmailCampaignBatchNotification: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getEmailCampaignBatchNotification(args),
+    providesTags: ["EmailCampaigns"]
+  }),
+  getEmailCampaignBatchNotifications: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getEmailCampaignBatchNotifications(args),
+    providesTags: ["EmailCampaigns"]
+  }),
+  getEmailCampaignStatistics: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getEmailCampaignStatistics(args),
+    providesTags: ["EmailCampaigns"]
+  }),
+  previewEmailNotification: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.previewEmailNotification(args),
+    providesTags: ["Emails"]
+  }),
+  getEmailCampaignMessage: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getEmailCampaignMessage(args),
+    providesTags: ["EmailCampaigns"]
+  }),
+  getEmailCampaignMessages: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getEmailCampaignMessages(args),
+    providesTags: ["EmailCampaigns"]
+  }),
+  disableSms: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.disableSms(args),
+    invalidatesTags: ["Sms"]
+  }),
+  enableSms: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.enableSms(args),
+    invalidatesTags: ["Sms"]
+  }),
+  archiveSmsTemplate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.archiveSmsTemplate(args),
+    invalidatesTags: ["SmsTemplates"]
+  }),
+  cloneSmsTemplate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.cloneSmsTemplate(args),
+    invalidatesTags: ["SmsTemplates"]
+  }),
+  createSmsTemplate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.createSmsTemplate(args),
+    invalidatesTags: ["SmsTemplates"]
+  }),
+  deleteSmsTemplate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.deleteSmsTemplate(args),
+    invalidatesTags: ["SmsTemplates"]
+  }),
+  getSmsTemplate: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getSmsTemplate(args),
+    providesTags: ["SmsTemplates"]
+  }),
+  getSmsTemplates: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getSmsTemplates(args),
+    providesTags: ["SmsTemplates"]
+  }),
+  getSmsMessageContentTokens: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getSmsMessageContentTokens(args),
+    providesTags: ["Sms"]
+  }),
+  unArchiveSmsTemplate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.unArchiveSmsTemplate(args),
+    invalidatesTags: ["SmsTemplates"]
+  }),
+  updateSmsTemplate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.updateSmsTemplate(args),
+    invalidatesTags: ["SmsTemplates"]
+  }),
+  getSmsSettings: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getSmsSettings(args),
+    providesTags: ["SmsSettings"]
+  }),
+  confirmSmsIntegrationHumanDelivery: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.confirmSmsIntegrationHumanDelivery(args),
+    invalidatesTags: ["SmsIntegrations"]
+  }),
+  deleteSmsIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.deleteSmsIntegration(args),
+    invalidatesTags: ["SmsIntegrations"]
+  }),
+  disableSmsIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.disableSmsIntegration(args),
+    invalidatesTags: ["SmsIntegrations"]
+  }),
+  enableSmsIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.enableSmsIntegration(args),
+    invalidatesTags: ["SmsIntegrations"]
+  }),
+  getSmsIntegration: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getSmsIntegration(args),
+    providesTags: ["SmsIntegrations"]
+  }),
+  getSmsIntegrations: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getSmsIntegrations(args),
+    providesTags: ["SmsIntegrations"]
+  }),
+  saveSmsIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.saveSmsIntegration(args),
+    invalidatesTags: ["SmsIntegrations"]
+  }),
+  setSmsIntegrationAsDefault: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.setSmsIntegrationAsDefault(args),
+    invalidatesTags: ["SmsIntegrations"]
+  }),
+  testSmsIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.testSmsIntegration(args),
+    invalidatesTags: ["SmsIntegrations"]
+  }),
+  createSmsCampaign: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.createSmsCampaign(args),
+    invalidatesTags: ["SmsCampaigns"]
+  }),
+  deleteSmsCampaign: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.deleteSmsCampaign(args),
+    invalidatesTags: ["SmsCampaigns"]
+  }),
+  getSmsCampaign: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getSmsCampaign(args),
+    providesTags: ["SmsCampaigns"]
+  }),
+  getSmsCampaigns: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getSmsCampaigns(args),
+    providesTags: ["SmsCampaigns"]
+  }),
+  getSmsCampaignBatches: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getSmsCampaignBatches(args),
+    providesTags: ["SmsCampaigns"]
+  }),
+  getSmsCampaignBatchNotification: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getSmsCampaignBatchNotification(args),
+    providesTags: ["SmsCampaigns"]
+  }),
+  getSmsCampaignBatchNotifications: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getSmsCampaignBatchNotifications(args),
+    providesTags: ["SmsCampaigns"]
+  }),
+  getSmsCampaignStatistics: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getSmsCampaignStatistics(args),
+    providesTags: ["SmsCampaigns"]
+  }),
+  previewSmsNotification: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.previewSmsNotification(args),
+    providesTags: ["Sms"]
+  }),
+  getSmsCampaignMessage: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getSmsCampaignMessage(args),
+    providesTags: ["SmsCampaigns"]
+  }),
+  getSmsCampaignMessages: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getSmsCampaignMessages(args),
+    providesTags: ["SmsCampaigns"]
+  }),
+  disablePush: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.disablePush(args),
+    invalidatesTags: ["Push"]
+  }),
+  enablePush: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.enablePush(args),
+    invalidatesTags: ["Push"]
+  }),
+  archivePushTemplate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.archivePushTemplate(args),
+    invalidatesTags: ["PushTemplates"]
+  }),
+  clonePushTemplate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.clonePushTemplate(args),
+    invalidatesTags: ["PushTemplates"]
+  }),
+  createPushTemplate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.createPushTemplate(args),
+    invalidatesTags: ["PushTemplates"]
+  }),
+  deletePushTemplate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.deletePushTemplate(args),
+    invalidatesTags: ["PushTemplates"]
+  }),
+  getPushTemplate: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getPushTemplate(args),
+    providesTags: ["PushTemplates"]
+  }),
+  getPushTemplates: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getPushTemplates(args),
+    providesTags: ["PushTemplates"]
+  }),
+  getPushMessageContentTokens: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getPushMessageContentTokens(args),
+    providesTags: ["Push"]
+  }),
+  unArchivePushTemplate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.unArchivePushTemplate(args),
+    invalidatesTags: ["PushTemplates"]
+  }),
+  updatePushTemplate: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.updatePushTemplate(args),
+    invalidatesTags: ["PushTemplates"]
+  }),
+  getPushSettings: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getPushSettings(args),
+    providesTags: ["Push"]
+  }),
+  confirmPushIntegrationHumanDelivery: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.confirmPushIntegrationHumanDelivery(args),
+    invalidatesTags: ["PushIntegrations"]
+  }),
+  deletePushIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.deletePushIntegration(args),
+    invalidatesTags: ["PushIntegrations"]
+  }),
+  disablePushIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.disablePushIntegration(args),
+    invalidatesTags: ["PushIntegrations"]
+  }),
+  enablePushIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.enablePushIntegration(args),
+    invalidatesTags: ["PushIntegrations"]
+  }),
+  getPushIntegration: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getPushIntegration(args),
+    providesTags: ["PushIntegrations"]
+  }),
+  getPushIntegrations: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getPushIntegrations(args),
+    providesTags: ["PushIntegrations"]
+  }),
+  savePushIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.savePushIntegration(args),
+    invalidatesTags: ["PushIntegrations"]
+  }),
+  setPushIntegrationAsDefault: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.setPushIntegrationAsDefault(args),
+    invalidatesTags: ["PushIntegrations"]
+  }),
+  testPushIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.testPushIntegration(args),
+    invalidatesTags: ["PushIntegrations"]
+  }),
+  registerCodeMashAppPushIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.registerCodeMashAppPushIntegration(args),
+    invalidatesTags: ["PushIntegrations"]
+  }),
+  registerDevice: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.registerDevice(args),
+    invalidatesTags: ["Push"]
+  }),
+  createPushCampaign: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.createPushCampaign(args),
+    invalidatesTags: ["PushCampaigns"]
+  }),
+  deletePushCampaign: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.deletePushCampaign(args),
+    invalidatesTags: ["PushCampaigns"]
+  }),
+  getPushCampaign: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getPushCampaign(args),
+    providesTags: ["PushCampaigns"]
+  }),
+  getPushCampaigns: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getPushCampaigns(args),
+    providesTags: ["PushCampaigns"]
+  }),
+  getPushCampaignBatches: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getPushCampaignBatches(args),
+    providesTags: ["PushCampaigns"]
+  }),
+  getPushCampaignBatchNotification: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getPushCampaignBatchNotification(args),
+    providesTags: ["PushCampaigns"]
+  }),
+  getPushCampaignBatchNotifications: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getPushCampaignBatchNotifications(args),
+    providesTags: ["PushCampaigns"]
+  }),
+  getPushCampaignStatistics: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getPushCampaignStatistics(args),
+    providesTags: ["PushCampaigns"]
+  }),
+  getPushCampaignMessage: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getPushCampaignMessage(args),
+    providesTags: ["PushCampaigns"]
+  }),
+  getPushCampaignMessages: b.query({
+    query: (args) => (norbix) => norbix.hub.notifications.getPushCampaignMessages(args),
+    providesTags: ["PushCampaigns"]
+  }),
+  createContact: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.createContact(args),
+    invalidatesTags: ["Contacts"]
+  }),
+  deleteContact: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.deleteContact(args),
+    invalidatesTags: ["Contacts"]
+  }),
+  getContact: b.query({
+    query: (args) => (norbix) => norbix.hub.membership.getContact(args),
+    providesTags: ["Contacts"]
+  }),
+  getAllContacts: b.query({
+    query: (args) => (norbix) => norbix.hub.membership.getAllContacts(args),
+    providesTags: ["Contacts"]
+  }),
+  mergeContacts: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.mergeContacts(args),
+    invalidatesTags: ["Contacts"]
+  }),
+  grantContactConsent: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.grantContactConsent(args),
+    invalidatesTags: ["Contacts"]
+  }),
+  unsubscribeContact: b.mutation({
+    query: (args) => (norbix) => norbix.hub.notifications.unsubscribeContact(args),
+    invalidatesTags: ["Contacts"]
+  }),
+  addContactIdentity: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.addContactIdentity(args),
+    invalidatesTags: ["Contacts"]
+  }),
+  promoteContactIdentity: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.promoteContactIdentity(args),
+    invalidatesTags: ["Contacts"]
+  }),
+  removeContactIdentity: b.mutation({
+    query: (args) => (norbix) => norbix.hub.membership.removeContactIdentity(args),
+    invalidatesTags: ["Contacts"]
+  })
+});
+
+// src/hooks/hub/payments.ts
+var hubPayments = (b) => ({
+  disablePayments: b.mutation({
+    query: (args) => (norbix) => norbix.hub.payments.disablePayments(args),
+    invalidatesTags: ["Payments"]
+  }),
+  enablePayments: b.mutation({
+    query: (args) => (norbix) => norbix.hub.payments.enablePayments(args),
+    invalidatesTags: ["Payments"]
+  }),
+  deletePaymentsTrigger: b.mutation({
+    query: (args) => (norbix) => norbix.hub.payments.deletePaymentsTrigger(args),
+    invalidatesTags: ["Triggers"]
+  }),
+  disablePaymentsTrigger: b.mutation({
+    query: (args) => (norbix) => norbix.hub.payments.disablePaymentsTrigger(args),
+    invalidatesTags: ["Triggers"]
+  }),
+  enablePaymentsTrigger: b.mutation({
+    query: (args) => (norbix) => norbix.hub.payments.enablePaymentsTrigger(args),
+    invalidatesTags: ["Triggers"]
+  }),
+  getPaymentsTrigger: b.query({
+    query: (args) => (norbix) => norbix.hub.payments.getPaymentsTrigger(args),
+    providesTags: ["Triggers"]
+  }),
+  getPaymentsTriggers: b.query({
+    query: (args) => (norbix) => norbix.hub.payments.getPaymentsTriggers(args),
+    providesTags: ["Triggers"]
+  }),
+  savePaymentsTrigger: b.mutation({
+    query: (args) => (norbix) => norbix.hub.payments.savePaymentsTrigger(args),
+    invalidatesTags: ["Triggers"]
+  }),
+  confirmPaymentsIntegrationHumanDelivery: b.mutation({
+    query: (args) => (norbix) => norbix.hub.payments.confirmPaymentsIntegrationHumanDelivery(args),
+    invalidatesTags: ["PaymentIntegrations"]
+  }),
+  deletePaymentsIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.payments.deletePaymentsIntegration(args),
+    invalidatesTags: ["PaymentIntegrations"]
+  }),
+  disablePaymentsIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.payments.disablePaymentsIntegration(args),
+    invalidatesTags: ["PaymentIntegrations"]
+  }),
+  enablePaymentsIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.payments.enablePaymentsIntegration(args),
+    invalidatesTags: ["PaymentIntegrations"]
+  }),
+  getPaymentsIntegration: b.query({
+    query: (args) => (norbix) => norbix.hub.payments.getPaymentsIntegration(args),
+    providesTags: ["PaymentIntegrations"]
+  }),
+  getPaymentsIntegrations: b.query({
+    query: (args) => (norbix) => norbix.hub.payments.getPaymentsIntegrations(args),
+    providesTags: ["PaymentIntegrations"]
+  }),
+  savePaymentsIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.payments.savePaymentsIntegration(args),
+    invalidatesTags: ["PaymentIntegrations"]
+  }),
+  testPaymentsIntegration: b.mutation({
+    query: (args) => (norbix) => norbix.hub.payments.testPaymentsIntegration(args),
+    invalidatesTags: ["PaymentIntegrations"]
+  })
+});
+
+// src/hooks/hub/regions.ts
+var hubRegions = (b) => ({
+  listRegions: b.query({
+    query: (args) => (norbix) => norbix.hub.regions.list(args),
+    providesTags: ["Regions"]
+  }),
+  updateProjectRegions: b.mutation({
+    query: (args) => (norbix) => norbix.hub.regions.updateProjectRegions(args),
+    // Changing the regions a project spans updates the project DTO
+    // (`primaryRegion` / `additionalRegions`).
+    invalidatesTags: ["Regions", "Projects"]
+  })
+});
+
+// src/hooks/hub/resources.ts
+var hubResources = (b) => ({
+  resolveResources: b.mutation({
+    query: (args) => (norbix) => norbix.hub.resources.resolveResources(args)
+  })
+});
+
+// src/hooks/hub/scheduler.ts
+var hubScheduler = (b) => {
+  const callHS = (norbix) => norbix.hub.scheduler;
+  return {
+    // ---- Module toggle ----
+    enableSchedulerModule: b.mutation({
+      query: (args) => (norbix) => callHS(norbix).enableScheduler(args),
+      invalidatesTags: ["Account", "Projects", "Scheduler"]
+    }),
+    disableSchedulerModule: b.mutation({
+      query: (args) => (norbix) => callHS(norbix).disableScheduler(args),
+      invalidatesTags: ["Account", "Projects", "Scheduler"]
+    }),
+    // ---- Tasks ----
+    getSchedulerTasks: b.query({
+      query: (args) => (norbix) => callHS(norbix).getSchedulerTasks(args),
+      providesTags: [{ type: "Scheduler", id: "LIST" }]
+    }),
+    getSchedulerTask: b.query({
+      query: (args) => (norbix) => callHS(norbix).getSchedulerTask(args),
+      providesTags: (_res, _err, arg) => [
+        { type: "Scheduler", id: arg?.id ?? "CURRENT" }
+      ]
+    }),
+    saveSchedulerTask: b.mutation({
+      query: (args) => (norbix) => callHS(norbix).saveSchedulerTask(args),
+      invalidatesTags: (_res, _err, arg) => [
+        { type: "Scheduler", id: "LIST" },
+        { type: "Scheduler", id: arg?.taskId ?? "CURRENT" }
+      ]
+    }),
+    enableSchedulerTask: b.mutation({
+      query: (args) => (norbix) => callHS(norbix).enableSchedulerTask(args),
+      invalidatesTags: (_res, _err, arg) => [
+        { type: "Scheduler", id: "LIST" },
+        { type: "Scheduler", id: arg?.id ?? "CURRENT" }
+      ]
+    }),
+    disableSchedulerTask: b.mutation({
+      query: (args) => (norbix) => callHS(norbix).disableSchedulerTask(args),
+      invalidatesTags: (_res, _err, arg) => [
+        { type: "Scheduler", id: "LIST" },
+        { type: "Scheduler", id: arg?.id ?? "CURRENT" }
+      ]
+    }),
+    deleteSchedulerTask: b.mutation({
+      query: (args) => (norbix) => callHS(norbix).deleteSchedulerTask(args),
+      invalidatesTags: (_res, _err, arg) => [
+        { type: "Scheduler", id: "LIST" },
+        { type: "Scheduler", id: arg?.id ?? "CURRENT" }
+      ]
+    })
+  };
+};
+
+// src/hooks/hub/webhooks.ts
+var hubWebhooks = (b) => ({
+  getWebhookIntegration: b.query({
+    query: (args) => (norbix) => norbix.hub.webhooks.getWebhookIntegration(args),
+    providesTags: ["Webhooks"]
+  }),
+  revealWebhookIntegrationSecret: b.mutation({
+    query: (args) => (norbix) => norbix.hub.webhooks.revealWebhookIntegrationSecret(args),
+    invalidatesTags: ["Webhooks"]
+  }),
+  rotateWebhookIntegrationSecret: b.mutation({
+    query: (args) => (norbix) => norbix.hub.webhooks.rotateWebhookIntegrationSecret(args),
+    invalidatesTags: ["Webhooks"]
+  }),
+  updateWebhookIntegrationExtraHeaders: b.mutation({
+    query: (args) => (norbix) => norbix.hub.webhooks.updateWebhookIntegrationExtraHeaders(args),
+    invalidatesTags: ["Webhooks"]
+  }),
+  receiveWebhook: b.mutation({
+    query: (args) => (norbix) => norbix.hub.webhooks.receiveWebhook(args),
+    invalidatesTags: ["Webhooks"]
+  }),
+  disableWebhookDestination: b.mutation({
+    query: (args) => (norbix) => norbix.hub.webhooks.disableWebhookDestination(args),
+    invalidatesTags: ["Webhooks"]
+  }),
+  enableWebhookDestination: b.mutation({
+    query: (args) => (norbix) => norbix.hub.webhooks.enableWebhookDestination(args),
+    invalidatesTags: ["Webhooks"]
+  }),
+  removeWebhookDestination: b.mutation({
+    query: (args) => (norbix) => norbix.hub.webhooks.removeWebhookDestination(args),
+    invalidatesTags: ["Webhooks"]
+  }),
+  saveWebhookDestination: b.mutation({
+    query: (args) => (norbix) => norbix.hub.webhooks.saveWebhookDestination(args),
+    invalidatesTags: ["Webhooks"]
+  })
+});
+
+// src/hooks/index.ts
+function buildEndpoints(builder) {
+  return {
+    // API surface (runtime, project-scoped)
+    ...apiAuth(builder),
+    ...apiMembership(builder),
+    ...apiDatabase(builder),
+    ...apiApikeys(builder),
+    ...apiChat(builder),
+    ...apiFiles(builder),
+    ...apiPublic(builder),
+    // Hub surface (control plane)
+    ...hubAccount(builder),
+    ...hubAi(builder),
+    ...hubApikeys(builder),
+    ...hubMembership(builder),
+    ...hubDatabase(builder),
+    ...hubFiles(builder),
+    ...hubLogs(builder),
+    ...hubNotifications(builder),
+    ...hubPayments(builder),
+    ...hubScheduler(builder),
+    ...hubEmail(builder),
+    ...hubEnvironments(builder),
+    ...hubRegions(builder),
+    ...hubResources(builder),
+    ...hubWebhooks(builder)
+  };
+}
+
+// src/createNorbixApi.ts
+function createNorbixApi(getClient, options = {}) {
+  const reducerPath = options.reducerPath ?? "norbix";
+  return react$1.createApi({
+    reducerPath,
+    baseQuery: createNorbixBaseQuery(getClient),
+    tagTypes: [
+      // Account / config
+      "Config",
+      "Account",
+      "AccountProfile",
+      "AccountUsers",
+      "Billing",
+      "Projects",
+      "Environments",
+      "Regions",
+      "ApiKey",
+      // Membership
+      "Membership",
+      "MembershipUsers",
+      "MembershipRoles",
+      "MembershipPolicies",
+      "MembershipIntegrations",
+      // Database
+      "Database",
+      "DatabaseSchemas",
+      "DatabaseCollections",
+      "DatabaseRecords",
+      "DatabaseTaxonomies",
+      "DatabaseTaxonomyTerms",
+      "DatabaseAggregates",
+      "DatabaseIntegrations",
+      "DatabaseImports",
+      "DatabaseExports",
+      "DatabaseBackups",
+      // Files
+      "Files",
+      "FilesIntegrations",
+      // Code
+      "Code",
+      "CodeIntegrations",
+      "CodeFunctions",
+      "CodeMarketplace",
+      // Email
+      "Emails",
+      "EmailTemplates",
+      "EmailCampaigns",
+      "EmailIntegrations",
+      "EmailSignatures",
+      "EmailFooters",
+      "EmailSettings",
+      // Push
+      "Push",
+      "PushTemplates",
+      "PushCampaigns",
+      "PushIntegrations",
+      // Sms
+      "Sms",
+      "SmsTemplates",
+      "SmsCampaigns",
+      "SmsIntegrations",
+      "SmsSettings",
+      // Payments
+      "Payments",
+      "PaymentIntegrations",
+      "PaymentPlans",
+      "PaymentDiscounts",
+      "PaymentCustomers",
+      // AI
+      "Ai",
+      // Webhooks
+      "Webhooks",
+      // Contacts
+      "Contacts",
+      // Other
+      "Scheduler",
+      "Triggers",
+      "Logs",
+      "LogsIntegrations"
+    ],
+    endpoints: (builder) => buildEndpoints(builder)
+  });
+}
+var NorbixContext = react.createContext(null);
+function NorbixProvider({ client, children }) {
+  const value = react.useMemo(() => client, [client]);
+  return /* @__PURE__ */ jsxRuntime.jsx(NorbixContext.Provider, { value, children });
+}
+function useNorbix() {
+  const client = react.useContext(NorbixContext);
+  if (!client) {
+    throw new Error(
+      "@norbix.ai/react-redux: useNorbix() must be called inside <NorbixProvider client={...}>."
+    );
+  }
+  return client;
+}
+function useOptionalNorbix() {
+  return react.useContext(NorbixContext);
+}
+
+// src/helpers/integrations.ts
+function buildIntegrationsEndpoints(b, opts) {
+  const { tag, prefix, namespace } = opts;
+  const m = opts.methodNames ?? {};
+  const list = m.list ?? `get${prefix}Integrations`;
+  const one = m.one ?? `get${prefix}Integration`;
+  const save = m.save ?? `save${prefix}Integration`;
+  const del = m.delete ?? `delete${prefix}Integration`;
+  const enable = m.enable ?? `enable${prefix}Integration`;
+  const disable = m.disable ?? `disable${prefix}Integration`;
+  const setDefault = m.setDefault ?? `set${prefix}IntegrationAsDefault`;
+  const test = m.test ?? `test${prefix}Integration`;
+  const confirmHumanDelivery = m.confirmHumanDelivery ?? `confirm${prefix}IntegrationHumanDelivery`;
+  const callMethod = (methodName) => (args) => (norbix) => {
+    const ns = namespace(norbix);
+    const fn = ns[methodName];
+    if (typeof fn !== "function") {
+      return Promise.reject(
+        new Error(
+          `@norbix.ai/react-redux: SDK method "${methodName}" not found. Check your SDK version or pass methodNames overrides.`
+        )
+      );
+    }
+    return fn(args);
+  };
+  const endpoints = {
+    [list]: b.query({
+      query: callMethod(list),
+      providesTags: [{ type: tag, id: "INTEGRATIONS_LIST" }]
+    }),
+    [one]: b.query({
+      query: callMethod(one),
+      providesTags: (_r, _e, arg) => [{ type: tag, id: arg?.id ?? "CURRENT" }]
+    }),
+    [save]: b.mutation({
+      query: callMethod(save),
+      invalidatesTags: (_r, _e, arg) => [
+        { type: tag, id: "INTEGRATIONS_LIST" },
+        { type: tag, id: arg?.id ?? "" }
+      ]
+    }),
+    [del]: b.mutation({
+      query: callMethod(del),
+      invalidatesTags: (_r, _e, arg) => [
+        { type: tag, id: "INTEGRATIONS_LIST" },
+        { type: tag, id: arg?.id ?? "" }
+      ]
+    }),
+    [enable]: b.mutation({
+      query: callMethod(enable),
+      invalidatesTags: (_r, _e, arg) => [
+        { type: tag, id: "INTEGRATIONS_LIST" },
+        { type: tag, id: arg?.id ?? "" }
+      ]
+    }),
+    [disable]: b.mutation({
+      query: callMethod(disable),
+      invalidatesTags: (_r, _e, arg) => [
+        { type: tag, id: "INTEGRATIONS_LIST" },
+        { type: tag, id: arg?.id ?? "" }
+      ]
+    }),
+    [setDefault]: b.mutation({
+      query: callMethod(setDefault),
+      invalidatesTags: (_r, _e, arg) => [
+        { type: tag, id: "INTEGRATIONS_LIST" },
+        { type: tag, id: arg?.id ?? "" }
+      ]
+    })
+  };
+  if (opts.include?.test !== false) {
+    endpoints[test] = b.mutation({
+      query: callMethod(test),
+      invalidatesTags: (_r, _e, arg) => arg?.integrationId ? [{ type: tag, id: arg.integrationId }] : []
+    });
+  }
+  if (opts.include?.confirmHumanDelivery === true) {
+    endpoints[confirmHumanDelivery] = b.mutation({
+      query: callMethod(confirmHumanDelivery),
+      invalidatesTags: (_r, _e, arg) => arg?.integrationId ? [{ type: tag, id: arg.integrationId }] : []
+    });
+  }
+  return endpoints;
+}
+
+exports.NorbixProvider = NorbixProvider;
+exports.buildIntegrationsEndpoints = buildIntegrationsEndpoints;
+exports.createNorbixApi = createNorbixApi;
+exports.createNorbixBaseQuery = createNorbixBaseQuery;
+exports.serializeNorbixError = serializeNorbixError;
+exports.useNorbix = useNorbix;
+exports.useOptionalNorbix = useOptionalNorbix;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map