@fusebase/fusebase-gate-sdk 2.2.2-sdk.2 → 2.2.2-sdk.20

package/dist/apis/IsolatedStoresApi.js

@@ -0,0 +1,426 @@
+"use strict";
+/**
+ * IsolatedStores API
+ *
+ * Generated from contract introspection
+ * Domain: isolated-stores
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsolatedStoresApi = void 0;
+class IsolatedStoresApi {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Batch insert rows
+     * Inserts multiple rows into a postgres table with a shared column set. Row cap per request is floor(65535 / columnCount) (Postgres bind-parameter limit). For very large loads use importIsolatedStoreSqlRows (COPY FROM STDIN).
+     */
+    async batchInsertIsolatedStoreSqlRows(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/sql/rows/batch-insert",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "batchInsertIsolatedStoreSqlRows",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Count isolated store NoSQL documents
+     * Counts documents in a nosql/mongodb_atlas isolated store stage using the same portable filter operators as query: eq, ne, gt, gte, lt, lte, in, and exists.
+     */
+    async countIsolatedStoreNoSqlDocuments(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/nosql/count-documents",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "countIsolatedStoreNoSqlDocuments",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Count rows
+     * Counts rows in a postgres table using simple structured filters. Useful for pagination without writing raw SQL.
+     */
+    async countIsolatedStoreSqlRows(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/sql/rows/count",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "countIsolatedStoreSqlRows",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Create isolated store
+     * Registers a low-level store and binds it to the organization scope plus a isolated source scope such as app or app_feature.
+     */
+    async createIsolatedStore(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/:orgId/isolated-stores",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "createIsolatedStore",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Create isolated store checkpoint
+     * Creates a new revision marker for the selected stage instance. For sql/postgres stages, gate also creates a physical pg_dump snapshot; for nosql/mongodb_atlas stages, gate creates a physical mongodump archive. The resulting file URL is stored in snapshotRef; a caller-provided snapshotRef is preserved in revision metadata as an external reference.
+     */
+    async createIsolatedStoreCheckpoint(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/checkpoints",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "createIsolatedStoreCheckpoint",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Create isolated store NoSQL collection
+     * Creates a collection for a nosql/mongodb_atlas isolated store stage. Collection names use safe identifiers with letters, numbers, and underscores.
+     */
+    async createIsolatedStoreNoSqlCollection(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/nosql/collections",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "createIsolatedStoreNoSqlCollection",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Delete isolated store NoSQL document
+     * Deletes a document by `_id` from a nosql/mongodb_atlas isolated store stage.
+     */
+    async deleteIsolatedStoreNoSqlDocument(params) {
+        return this.client.request({
+            method: "DELETE",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/nosql/collections/:collectionName/documents/:documentId",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "deleteIsolatedStoreNoSqlDocument",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Delete rows
+     * Deletes rows from a postgres table using structured filters. Filterless deletes are blocked unless allowAll=true is explicitly set.
+     */
+    async deleteIsolatedStoreSqlRows(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/sql/rows/delete",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "deleteIsolatedStoreSqlRows",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Delete isolated store stage
+     * Removes the stage instance and its revisions. When the stage was auto-provisioned on the isolated Postgres or isolated Mongo server, gate also drops the provisioned database after registry rows are removed.
+     */
+    async deleteIsolatedStoreStage(params) {
+        return this.client.request({
+            method: "DELETE",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "deleteIsolatedStoreStage",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Describe isolated store SQL table
+     * Returns postgres column metadata for a single table in the selected isolated store stage instance.
+     */
+    async describeIsolatedStoreSqlTable(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/sql/tables/:tableName",
+            pathParams: params.path,
+            query: params.query,
+            headers: params.headers,
+            opId: "describeIsolatedStoreSqlTable",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Run writable SQL statement
+     * Runs a single SQL statement with execute access against the postgres binding of the selected isolated store stage instance.
+     */
+    async executeIsolatedStoreSql(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/sql/execute",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "executeIsolatedStoreSql",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Get isolated store
+     * Returns a single isolated store by store global id within the organization scope.
+     */
+    async getIsolatedStore(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/:orgId/isolated-stores/:storeId",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "getIsolatedStore",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Get isolated store NoSQL document
+     * Gets a document by `_id` from a nosql/mongodb_atlas isolated store stage. The document identity comes from the `documentId` path parameter.
+     */
+    async getIsolatedStoreNoSqlDocument(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/nosql/collections/:collectionName/documents/:documentId",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "getIsolatedStoreNoSqlDocument",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Import NDJSON documents
+     * Imports newline-delimited JSON documents into a Mongo collection. Use this bulk path for large seed or migration-style writes instead of per-document tool calls.
+     */
+    async importIsolatedStoreNoSqlDocuments(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/nosql/import-documents",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "importIsolatedStoreNoSqlDocuments",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Import CSV or TSV rows
+     * Imports CSV or TSV payloads into a postgres table using server-side COPY FROM STDIN. Use this bulk path for large seeds or migrations instead of repeated row inserts. Max UTF-8 payload size defaults to 64MiB (override ISOLATED_SQL_IMPORT_MAX_PAYLOAD_BYTES; hard cap 256MiB); split larger files across multiple calls.
+     */
+    async importIsolatedStoreSqlRows(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/sql/rows/import",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "importIsolatedStoreSqlRows",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Initialize isolated store stage
+     * Creates a stage instance. For postgres and mongodb_atlas, gate can auto-provision a dedicated stage database when the corresponding isolated server is configured; otherwise an explicit bindingConfig is required.
+     */
+    async initIsolatedStoreStage(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/:orgId/isolated-stores/:storeId/stages",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "initIsolatedStoreStage",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Insert row
+     * Inserts a single row into a postgres table and optionally returns selected columns.
+     */
+    async insertIsolatedStoreSqlRow(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/sql/rows/insert",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "insertIsolatedStoreSqlRow",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * List isolated store NoSQL collections
+     * Lists collections for a nosql/mongodb_atlas isolated store stage. The same contract can be backed by a local isolated Mongo server in development.
+     */
+    async listIsolatedStoreNoSqlCollections(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/nosql/collections",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "listIsolatedStoreNoSqlCollections",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * List isolated store revisions
+     * Returns version checkpoints for a specific isolated store stage instance.
+     */
+    async listIsolatedStoreRevisions(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/revisions",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "listIsolatedStoreRevisions",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * List isolated stores
+     * Returns the isolated store registry for the organization. This is a control-plane endpoint behind FEATURE_FLAGS=isolated_stores.
+     */
+    async listIsolatedStores(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/:orgId/isolated-stores",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "listIsolatedStores",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * List isolated store SQL tables
+     * Returns postgres tables and views for the requested isolated store stage instance. Token access must include the matching isolated_store_stage_instance resource scope.
+     */
+    async listIsolatedStoreSqlTables(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/sql/tables",
+            pathParams: params.path,
+            query: params.query,
+            headers: params.headers,
+            opId: "listIsolatedStoreSqlTables",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * List isolated store stages
+     * Returns stage instances for the selected isolated store. MVP uses separate stage instances for dev and prod.
+     */
+    async listIsolatedStoreStages(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/:orgId/isolated-stores/:storeId/stages",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "listIsolatedStoreStages",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Put isolated store NoSQL document
+     * Upserts a document by `_id` into a nosql/mongodb_atlas isolated store stage. The `documentId` path parameter is the source of truth for `_id` and overrides any `_id` inside the body document.
+     */
+    async putIsolatedStoreNoSqlDocument(params) {
+        return this.client.request({
+            method: "PUT",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/nosql/collections/:collectionName/documents/:documentId",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "putIsolatedStoreNoSqlDocument",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Query isolated store NoSQL documents
+     * Queries documents from a nosql/mongodb_atlas isolated store stage using portable filters, sort and pagination. Supported operators are eq, ne, gt, gte, lt, lte, in, and exists. Default limit is 100, max limit is 500, max filters is 20, and max sort fields is 5.
+     */
+    async queryIsolatedStoreNoSqlDocuments(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/nosql/query-documents",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "queryIsolatedStoreNoSqlDocuments",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Run read-only SQL query
+     * Runs a single read-only SQL statement against the postgres binding of the selected isolated store stage instance.
+     */
+    async queryIsolatedStoreSql(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/sql/query",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "queryIsolatedStoreSql",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Restore isolated store revision
+     * Restores a sql/postgres or nosql/mongodb_atlas stage from a previously created physical file snapshot. For auto-provisioned dedicated stage databases, gate recreates or clears the target database before running pg_restore or mongorestore. Only file:// snapshotRef values are restorable in MVP.
+     */
+    async restoreIsolatedStoreRevision(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/revisions/:revisionId/restore",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "restoreIsolatedStoreRevision",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Select rows
+     * Reads rows from a postgres table using simple filters, sort, limit and offset. This is the primary low-overhead runtime read surface.
+     */
+    async selectIsolatedStoreSqlRows(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/sql/rows/select",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "selectIsolatedStoreSqlRows",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Update rows
+     * Updates rows in a postgres table using structured filters. Filterless updates are blocked unless allowAll=true is explicitly set.
+     */
+    async updateIsolatedStoreSqlRows(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/:orgId/isolated-stores/:storeId/stages/:stage/sql/rows/update",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "updateIsolatedStoreSqlRows",
+            expectedContentType: "application/json",
+        });
+    }
+}
+exports.IsolatedStoresApi = IsolatedStoresApi;

package/dist/apis/NotesApi.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Notes API
+ *
+ * Generated from contract introspection
+ * Domain: notes
+ */
+import type { Client } from "../runtime/transport";
+import type { CreateWorkspaceNoteFolderRequestContract, CreateWorkspaceNoteFolderResponseContract, CreateWorkspaceNoteRequestContract, CreateWorkspaceNoteResponseContract, orgIdInPathRequired, WorkspaceIdInPathRequired, WorkspaceNoteContentResponseContract, WorkspaceNoteFolderListResponseContract, WorkspaceNoteIdInPathRequired, WorkspaceNoteListResponseContract, WorkspaceNoteParentIdInQueryOptional } from "../types";
+export declare class NotesApi {
+    private client;
+    constructor(client: Client);
+    /**
+     * Create workspace note
+     * Creates a note in the requested workspace. When parentId is omitted, gate uses `default`. Optional initial text or html can be appended after creation.
+     */
+    createWorkspaceNote(params: {
+        path: {
+            orgId: orgIdInPathRequired;
+            workspaceId: WorkspaceIdInPathRequired;
+        };
+        headers?: Record<string, string>;
+        body: CreateWorkspaceNoteRequestContract;
+    }): Promise<CreateWorkspaceNoteResponseContract>;
+    /**
+     * Create workspace note folder
+     * Creates a folder in the requested workspace. When parentId is omitted, gate uses `default`.
+     */
+    createWorkspaceNoteFolder(params: {
+        path: {
+            orgId: orgIdInPathRequired;
+            workspaceId: WorkspaceIdInPathRequired;
+        };
+        headers?: Record<string, string>;
+        body: CreateWorkspaceNoteFolderRequestContract;
+    }): Promise<CreateWorkspaceNoteFolderResponseContract>;
+    /**
+     * Read workspace note
+     * Returns the note title, parent metadata, and md content for the requested workspace note.
+     */
+    getWorkspaceNote(params: {
+        path: {
+            orgId: orgIdInPathRequired;
+            workspaceId: WorkspaceIdInPathRequired;
+            noteId: WorkspaceNoteIdInPathRequired;
+        };
+        headers?: Record<string, string>;
+    }): Promise<WorkspaceNoteContentResponseContract>;
+    /**
+     * List workspace note folders
+     * Returns non-portal note folders for the requested workspace.
+     */
+    listWorkspaceNoteFolders(params: {
+        path: {
+            orgId: orgIdInPathRequired;
+            workspaceId: WorkspaceIdInPathRequired;
+        };
+        headers?: Record<string, string>;
+    }): Promise<WorkspaceNoteFolderListResponseContract>;
+    /**
+     * List workspace notes
+     * Returns non-portal notes for the requested workspace and parent folder. When parentId is omitted, gate defaults to the workspace default folder id `default`.
+     */
+    listWorkspaceNotes(params: {
+        path: {
+            orgId: orgIdInPathRequired;
+            workspaceId: WorkspaceIdInPathRequired;
+        };
+        query?: {
+            parentId?: WorkspaceNoteParentIdInQueryOptional;
+        };
+        headers?: Record<string, string>;
+    }): Promise<WorkspaceNoteListResponseContract>;
+}

package/dist/apis/NotesApi.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * Notes API
+ *
+ * Generated from contract introspection
+ * Domain: notes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotesApi = void 0;
+class NotesApi {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Create workspace note
+     * Creates a note in the requested workspace. When parentId is omitted, gate uses `default`. Optional initial text or html can be appended after creation.
+     */
+    async createWorkspaceNote(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/:orgId/workspaces/:workspaceId/notes",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "createWorkspaceNote",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Create workspace note folder
+     * Creates a folder in the requested workspace. When parentId is omitted, gate uses `default`.
+     */
+    async createWorkspaceNoteFolder(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/:orgId/workspaces/:workspaceId/notes/folders",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "createWorkspaceNoteFolder",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Read workspace note
+     * Returns the note title, parent metadata, and md content for the requested workspace note.
+     */
+    async getWorkspaceNote(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/:orgId/workspaces/:workspaceId/notes/:noteId",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "getWorkspaceNote",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * List workspace note folders
+     * Returns non-portal note folders for the requested workspace.
+     */
+    async listWorkspaceNoteFolders(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/:orgId/workspaces/:workspaceId/notes/folders",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "listWorkspaceNoteFolders",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * List workspace notes
+     * Returns non-portal notes for the requested workspace and parent folder. When parentId is omitted, gate defaults to the workspace default folder id `default`.
+     */
+    async listWorkspaceNotes(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/:orgId/workspaces/:workspaceId/notes",
+            pathParams: params.path,
+            query: params.query,
+            headers: params.headers,
+            opId: "listWorkspaceNotes",
+            expectedContentType: "application/json",
+        });
+    }
+}
+exports.NotesApi = NotesApi;

package/dist/apis/OrgUsersApi.d.ts

@@ -11,7 +11,7 @@ export declare class OrgUsersApi {
     constructor(client: Client);
     /**
      * Add user to organization
-     * Invites a user into the organization. Without workspaceId it performs an org invite. With workspaceId it performs a workspace-aware invite and can resolve `default` to the organization's default workspace. Requires org.members.write and org access.
+     * Invites a user into the organization. Without workspaceId it performs an org invite. With workspaceId it performs a workspace-aware invite and can resolve `default` to the organization's default workspace. For org-only instant client onboarding, send orgRole=`client` with autoConfirmClientInvite=`true`. A successful write does not prove that the current session already has org access; confirm access with getMyOrgAccess. Requires org.members.write and org access.
      */
     addOrgUser(params: {
         path: {

package/dist/apis/OrgUsersApi.js

@@ -13,7 +13,7 @@ class OrgUsersApi {
     }
     /**
      * Add user to organization
-     * Invites a user into the organization. Without workspaceId it performs an org invite. With workspaceId it performs a workspace-aware invite and can resolve `default` to the organization's default workspace. Requires org.members.write and org access.
+     * Invites a user into the organization. Without workspaceId it performs an org invite. With workspaceId it performs a workspace-aware invite and can resolve `default` to the organization's default workspace. For org-only instant client onboarding, send orgRole=`client` with autoConfirmClientInvite=`true`. A successful write does not prove that the current session already has org access; confirm access with getMyOrgAccess. Requires org.members.write and org access.
      */
     async addOrgUser(params) {
         return this.client.request({

package/dist/apis/SystemApi.d.ts

@@ -5,10 +5,17 @@
  * Domain: system
  */
 import type { Client } from "../runtime/transport";
-import type { ResolveOperationPermissionsRequestContract, ResolveOperationPermissionsResponseContract } from "../types";
+import type { ListPermissionCatalogResponseContract, ResolveOperationPermissionsRequestContract, ResolveOperationPermissionsResponseContract } from "../types";
 export declare class SystemApi {
     private client;
     constructor(client: Client);
+    /**
+     * List all registered permissions
+     * Return the full permission catalog registered by the current service, including platform base permissions and service-owned permissions.
+     */
+    listPermissionCatalog(params: {
+        headers?: Record<string, string>;
+    }): Promise<ListPermissionCatalogResponseContract>;
     /**
      * Resolve required permissions for operations
      * Return the unique required permissions for a list of operation identifiers. Supports exact operation ids and sanitized MCP tool names. Public operations contribute no permission.

package/dist/apis/SystemApi.js

@@ -11,6 +11,19 @@ class SystemApi {
     constructor(client) {
         this.client = client;
     }
+    /**
+     * List all registered permissions
+     * Return the full permission catalog registered by the current service, including platform base permissions and service-owned permissions.
+     */
+    async listPermissionCatalog(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/system/permissions/catalog",
+            headers: params.headers,
+            opId: "listPermissionCatalog",
+            expectedContentType: "application/json",
+        });
+    }
     /**
      * Resolve required permissions for operations
      * Return the unique required permissions for a list of operation identifiers. Supports exact operation ids and sanitized MCP tool names. Public operations contribute no permission.

package/dist/extras/fetchWithRetry.js

@@ -27,7 +27,12 @@ function createFetchWithRetry(baseFetch, { retries = 3, backoffMs = defaultBacko
                     ? backoffMs(attempt, lastResponse, lastError)
                     : backoffMs;
                 if (wait > 0) {
-                    console.log(`Waiting ${wait}ms before next attempt #${attempt}, ${lastError instanceof Error ? lastError.message : "unknown error"}`);
+                    const reason = lastError instanceof Error
+                        ? lastError.message
+                        : lastResponse != null
+                            ? `HTTP ${lastResponse.status} (retryable response)`
+                            : "unknown error";
+                    console.log(`Waiting ${wait}ms before next attempt #${attempt}, ${reason}`);
                     await sleep(wait);
                 }
             }

package/dist/index.d.ts

@@ -6,8 +6,11 @@
 export * from "./runtime";
 export * from "./types";
 export { AccessApi } from "./apis/AccessApi";
+export { BillingApi } from "./apis/BillingApi";
 export { EmailsApi } from "./apis/EmailsApi";
 export { HealthApi } from "./apis/HealthApi";
+export { IsolatedStoresApi } from "./apis/IsolatedStoresApi";
+export { NotesApi } from "./apis/NotesApi";
 export { OrgUsersApi } from "./apis/OrgUsersApi";
 export { PortalsApi } from "./apis/PortalsApi";
 export { SystemApi } from "./apis/SystemApi";