@unboundcx/sdk 4.13.0 → 4.13.2

package/index.js

@@ -32,6 +32,7 @@ import { TaskRouterService } from './services/taskRouter.js';
 import { KnowledgeBaseService } from './services/knowledgeBase.js';
 import { FaxService } from './services/fax.js';
 import { DocumentsService } from './services/documents.js';
+import { EsignService } from './services/esign.js';
 import { PermissionsService } from './services/permissions.js';
 import { TriggersService } from './services/triggers.js';
 import { RecentsService } from './services/recents.js';
@@ -112,6 +113,7 @@ class UnboundSDK extends BaseSDK {
     this.knowledgeBase = new KnowledgeBaseService(this);
     this.fax = new FaxService(this);
     this.documents = new DocumentsService(this);
+    this.esign = new EsignService(this);
     this.permissions = new PermissionsService(this);
     this.triggers = new TriggersService(this);
     this.recents = new RecentsService(this);
@@ -307,6 +309,7 @@ export { TaskRouterService } from './services/taskRouter.js';
 export { WorkerService } from './services/taskRouter/WorkerService.js';
 export { KnowledgeBaseService } from './services/knowledgeBase.js';
 export { FaxService } from './services/fax.js';
+export { EsignService, EsignPublicService } from './services/esign.js';
 export { PermissionsService } from './services/permissions.js';
 export { RecentsService } from './services/recents.js';
 export { SearchService } from './services/search.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unboundcx/sdk",
-  "version": "4.13.0",
+  "version": "4.13.2",
   "description": "Official JavaScript SDK for the Unbound API - A comprehensive toolkit for integrating with Unbound's communication, AI, and data management services",
   "main": "index.js",
   "type": "module",

package/services/chat.js

@@ -970,6 +970,89 @@ export class ChatService {
     });
   }
 
+  /**
+   * Admin: hide a reported message from user-facing chat (reversible).
+   * Content stays visible to admins. Creates/updates the permanent
+   * moderation case for the message.
+   * @param {string} id
+   * @returns {Promise<Object>} the hidden message, plus `caseId`
+   */
+  async adminHideMessage(id) {
+    this.sdk.validateParams({ id }, { id: { type: "string", required: true } });
+    return internalRequest(this.sdk, `/chat/admin/messages/${id}/hide`, "POST");
+  }
+
+  /**
+   * Admin: apply the final disposition to a hidden (or never-hidden)
+   * message — restore it, delete it (stays hidden, content retained
+   * subject to retention), or purge it (content expunged everywhere now).
+   * Also closes every open report on the message.
+   * @param {string} id
+   * @param {Object} params
+   * @param {'restore'|'delete'|'purge'} params.action
+   * @param {string} params.reason Free text, at least 3 characters
+   * @param {string} [params.description] Required (>= 3 chars) for `purge` —
+   *   describes what the content was, since the content itself is removed
+   * @returns {Promise<Object>} the updated message, plus `caseId`/`caseAction`
+   */
+  async adminDispositionMessage(id, { action, reason, description } = {}) {
+    this.sdk.validateParams(
+      { id, action, reason, description },
+      {
+        id: { type: "string", required: true },
+        action: { type: "string", required: true },
+        reason: { type: "string", required: true },
+        description: { type: "string", required: false },
+      },
+    );
+    const body = { action, reason };
+    if (description !== undefined) body.description = description;
+    return internalRequest(
+      this.sdk,
+      `/chat/admin/messages/${id}/disposition`,
+      "POST",
+      { body },
+    );
+  }
+
+  /**
+   * Admin: list moderation cases (permanent hide/disposition history).
+   * @param {Object} [params]
+   * @param {'open'|'closed'|'all'} [params.status]
+   * @param {string} [params.authorId]
+   * @param {string} [params.nextId] Pagination cursor (case id)
+   * @param {number} [params.limit]
+   * @returns {Promise<Object>} `{results, hasMore, nextId}`
+   */
+  async adminListCases({ status, authorId, nextId, limit } = {}) {
+    this.sdk.validateParams(
+      { status, authorId, nextId, limit },
+      {
+        status: { type: "string", required: false },
+        authorId: { type: "string", required: false },
+        nextId: { type: "string", required: false },
+        limit: { type: "number", required: false },
+      },
+    );
+    const query = {};
+    if (status !== undefined) query.status = status;
+    if (authorId !== undefined) query.authorId = authorId;
+    if (nextId !== undefined) query.nextId = nextId;
+    if (limit !== undefined) query.limit = limit;
+    return internalRequest(this.sdk, "/chat/admin/cases", "GET", { query });
+  }
+
+  /**
+   * Admin: get one moderation case — hydrated with its message (content
+   * per the usual rules) and reports.
+   * @param {string} id
+   * @returns {Promise<Object>}
+   */
+  async adminGetCase(id) {
+    this.sdk.validateParams({ id }, { id: { type: "string", required: true } });
+    return internalRequest(this.sdk, `/chat/admin/cases/${id}`, "GET");
+  }
+
   /**
    * Admin: audit log of review actions.
    * @returns {Promise<Object>}

package/services/documents.js

@@ -186,6 +186,7 @@ export class DocumentsService {
    * @param {string} [params.versionId]
    * @param {Object} [params.options]
    * @param {string} [params.options.filename]
+   * @param {boolean} [params.options.includeRecipientFieldMap] - Persist recipient field geometry for esign
    * @param {Object} [params.source]
    * @param {string} [params.source.type]
    * @param {string} [params.source.id]

package/services/drive.js

@@ -11,6 +11,10 @@ export class DriveService {
     return result;
   }
 
+  async listDrives() {
+    return internalRequest(this.sdk, '/drive/drives', 'GET');
+  }
+
   /**
    * List Google Drive files and folders.
    * @param {Object} [options]
@@ -236,17 +240,27 @@ export class DriveService {
    * @param {string} [options.sharedDriveId]
    * @param {boolean} [options.create]
    */
-  async resolvePath({ path, sharedDriveId, create } = {}) {
+  async resolvePath({
+    path,
+    sharedDriveId,
+    create,
+    objectName,
+    relatedId,
+  } = {}) {
     this.sdk.validateParams(
-      { path, sharedDriveId },
+      { path, sharedDriveId, objectName, relatedId },
       {
         path: { type: 'string', required: true },
         sharedDriveId: { type: 'string', required: false },
+        objectName: { type: 'string', required: false },
+        relatedId: { type: 'string', required: false },
       },
     );
     const body = { path };
     if (sharedDriveId !== undefined) body.sharedDriveId = sharedDriveId;
     if (create !== undefined) body.create = create;
+    if (objectName !== undefined) body.objectName = objectName;
+    if (relatedId !== undefined) body.relatedId = relatedId;
     return internalRequest(this.sdk, '/drive/resolvePath', 'POST', { body });
   }
 }

package/services/esign.js

@@ -0,0 +1,436 @@
+import { internalRequest } from '../base.js';
+
+/**
+ * Public (tokenized) signing session. `sdk.esign.public.*`.
+ * No tenant cookie; tenant is resolved from Host. All methods force HTTP
+ * so Present (Socket.IO SDK) does not NATS a Host-less request.
+ */
+export class EsignPublicService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  /**
+   * This-signer summary + disclosure (no co-signer emails).
+   * @param {Object} params
+   * @param {string} params.token - Raw signing token
+   * @returns {Promise<Object>}
+   */
+  async get({ token }) {
+    this.sdk.validateParams(
+      { token },
+      { token: { type: 'string', required: true } },
+    );
+    return internalRequest(this.sdk, `/esign/public/${token}`, 'GET', {}, true);
+  }
+
+  /**
+   * Composed working (or sealed) PDF for this signer.
+   * @param {Object} [params]
+   * @param {string} params.token
+   * @param {string} [params.kind] - `working` (default) or `sealed`
+   * @returns {Promise<*>} Raw PDF response
+   */
+  async getPdf({ token, kind } = {}) {
+    this.sdk.validateParams(
+      { token },
+      {
+        token: { type: 'string', required: true },
+        kind: { type: 'string', required: false },
+      },
+    );
+    const params = { returnRawResponse: true };
+    if (kind !== undefined) params.query = { kind };
+    return internalRequest(
+      this.sdk,
+      `/esign/public/${token}/pdf`,
+      'GET',
+      params,
+      true,
+    );
+  }
+
+  /**
+   * Record consent. Must precede complete.
+   * @param {Object} params
+   * @param {string} params.token
+   * @param {boolean} params.accepted - Must be true
+   * @param {string} params.disclosureSha256
+   * @returns {Promise<Object>}
+   */
+  async consent({ token, accepted, disclosureSha256 }) {
+    this.sdk.validateParams(
+      { token, accepted, disclosureSha256 },
+      {
+        token: { type: 'string', required: true },
+        accepted: { type: 'boolean', required: true },
+        disclosureSha256: { type: 'string', required: true },
+      },
+    );
+    return internalRequest(
+      this.sdk,
+      `/esign/public/${token}/consent`,
+      'POST',
+      { body: { accepted, disclosureSha256 } },
+      true,
+    );
+  }
+
+  /**
+   * Draft-save field values (not stamped).
+   * @param {Object} params
+   * @param {string} params.token
+   * @param {Object} params.values
+   * @returns {Promise<Object>}
+   */
+  async save({ token, values }) {
+    this.sdk.validateParams(
+      { token, values },
+      {
+        token: { type: 'string', required: true },
+        values: { type: 'object', required: true },
+      },
+    );
+    return internalRequest(
+      this.sdk,
+      `/esign/public/${token}/save`,
+      'POST',
+      { body: { values } },
+      true,
+    );
+  }
+
+  /**
+   * Complete this recipient (stamp + maybe seal).
+   * @param {Object} params
+   * @param {string} params.token
+   * @param {Object} [params.values]
+   * @param {string} [params.method]
+   * @param {string} [params.adoptedName]
+   * @param {string} [params.imagePngBase64]
+   * @returns {Promise<Object>}
+   */
+  async complete({ token, values, method, adoptedName, imagePngBase64 }) {
+    this.sdk.validateParams(
+      { token },
+      {
+        token: { type: 'string', required: true },
+        values: { type: 'object', required: false },
+        method: { type: 'string', required: false },
+        adoptedName: { type: 'string', required: false },
+        imagePngBase64: { type: 'string', required: false },
+      },
+    );
+    const body = {};
+    if (values !== undefined) body.values = values;
+    if (method !== undefined) body.method = method;
+    if (adoptedName !== undefined) body.adoptedName = adoptedName;
+    if (imagePngBase64 !== undefined) body.imagePngBase64 = imagePngBase64;
+    return internalRequest(
+      this.sdk,
+      `/esign/public/${token}/complete`,
+      'POST',
+      { body },
+      true,
+    );
+  }
+
+  /** Alias of {@link EsignPublicService#complete}. */
+  async sign(args) {
+    return this.complete(args);
+  }
+
+  /**
+   * Decline the package.
+   * @param {Object} params
+   * @param {string} params.token
+   * @param {string} [params.reason]
+   * @returns {Promise<Object>}
+   */
+  async decline({ token, reason }) {
+    this.sdk.validateParams(
+      { token },
+      {
+        token: { type: 'string', required: true },
+        reason: { type: 'string', required: false },
+      },
+    );
+    const body = {};
+    if (reason !== undefined) body.reason = reason;
+    return internalRequest(
+      this.sdk,
+      `/esign/public/${token}/decline`,
+      'POST',
+      { body },
+      true,
+    );
+  }
+}
+
+/**
+ * Authenticated signing packages. `sdk.esign.*`.
+ */
+export class EsignService {
+  constructor(sdk) {
+    this.sdk = sdk;
+    this.public = new EsignPublicService(sdk);
+  }
+
+  /**
+   * Create a draft package from a generated document.
+   * Field boxes come from the document's recipient field map, not the client.
+   * @param {Object} body
+   * @param {string} body.generatedDocumentId
+   * @param {string} body.name
+   * @param {Object[]} body.recipients
+   * @param {string} [body.routing] - `parallel` or `sequential`
+   * @param {Object[]} [body.links]
+   * @param {string} [body.expiresAt]
+   * @param {boolean} [body.allowDrawn]
+   * @param {string} [body.postSignRedirectUrl]
+   * @returns {Promise<Object>}
+   */
+  async createPackage({
+    generatedDocumentId,
+    name,
+    routing,
+    recipients,
+    links,
+    expiresAt,
+    allowDrawn,
+    postSignRedirectUrl,
+  } = {}) {
+    this.sdk.validateParams(
+      { generatedDocumentId, name, recipients },
+      {
+        generatedDocumentId: { type: 'string', required: true },
+        name: { type: 'string', required: true },
+        recipients: { type: 'array', required: true },
+        routing: { type: 'string', required: false },
+        links: { type: 'array', required: false },
+        expiresAt: { type: 'string', required: false },
+        allowDrawn: { type: 'boolean', required: false },
+        postSignRedirectUrl: { type: 'string', required: false },
+      },
+    );
+
+    const body = { generatedDocumentId, name, recipients };
+    if (routing !== undefined) body.routing = routing;
+    if (links !== undefined) body.links = links;
+    if (expiresAt !== undefined) body.expiresAt = expiresAt;
+    if (allowDrawn !== undefined) body.allowDrawn = allowDrawn;
+    if (postSignRedirectUrl !== undefined) {
+      body.postSignRedirectUrl = postSignRedirectUrl;
+    }
+
+    return internalRequest(this.sdk, '/esign/packages', 'POST', { body });
+  }
+
+  /**
+   * List packages. Missing tables → 503 `EsignNotProvisioned`.
+   * Gate probe: `listPackages({ limit: 1 })`.
+   * @param {Object} [query]
+   * @param {string} [query.recordId] - Requires `objectName`
+   * @param {string} [query.objectName] - Requires `recordId`
+   * @param {string} [query.status]
+   * @param {number} [query.limit]
+   * @returns {Promise<{results: Object[]}>}
+   */
+  async listPackages({ recordId, objectName, status, limit } = {}) {
+    const query = {};
+    if (recordId) query.recordId = recordId;
+    if (objectName) query.objectName = objectName;
+    if (status) query.status = status;
+    if (limit) query.limit = limit;
+    return internalRequest(this.sdk, '/esign/packages', 'GET', { query });
+  }
+
+  /**
+   * Package with signers, links, events (last 200).
+   * @param {string} id
+   * @returns {Promise<Object>}
+   */
+  async getPackage(id) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    return internalRequest(this.sdk, `/esign/packages/${id}`, 'GET');
+  }
+
+  /**
+   * Patch a draft package.
+   * @param {string} id
+   * @param {Object} [body]
+   * @param {string} [body.name]
+   * @param {Object[]} [body.recipients]
+   * @param {string} [body.routing]
+   * @param {Object[]} [body.links]
+   * @param {string} [body.expiresAt]
+   * @param {boolean} [body.allowDrawn]
+   * @param {string} [body.postSignRedirectUrl]
+   * @returns {Promise<Object>}
+   */
+  async updatePackage(
+    id,
+    {
+      name,
+      recipients,
+      routing,
+      links,
+      expiresAt,
+      allowDrawn,
+      postSignRedirectUrl,
+    } = {},
+  ) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+        name: { type: 'string', required: false },
+        recipients: { type: 'array', required: false },
+        routing: { type: 'string', required: false },
+        links: { type: 'array', required: false },
+        expiresAt: { type: 'string', required: false },
+        allowDrawn: { type: 'boolean', required: false },
+        postSignRedirectUrl: { type: 'string', required: false },
+      },
+    );
+
+    const body = {};
+    if (name !== undefined) body.name = name;
+    if (recipients !== undefined) body.recipients = recipients;
+    if (routing !== undefined) body.routing = routing;
+    if (links !== undefined) body.links = links;
+    if (expiresAt !== undefined) body.expiresAt = expiresAt;
+    if (allowDrawn !== undefined) body.allowDrawn = allowDrawn;
+    if (postSignRedirectUrl !== undefined) {
+      body.postSignRedirectUrl = postSignRedirectUrl;
+    }
+
+    return internalRequest(this.sdk, `/esign/packages/${id}`, 'PATCH', {
+      body,
+    });
+  }
+
+  /**
+   * Freeze disclosure, issue tokens, email recipients.
+   * @param {string} id
+   * @returns {Promise<Object>}
+   */
+  async send(id) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    return internalRequest(this.sdk, `/esign/packages/${id}/send`, 'POST', {
+      body: {},
+    });
+  }
+
+  /**
+   * Mint a present token (no email). `{ url, expiresAt }`.
+   * @param {string} id
+   * @param {Object} params
+   * @param {string} params.signerId
+   * @returns {Promise<Object>}
+   */
+  async present(id, { signerId }) {
+    this.sdk.validateParams(
+      { id, signerId },
+      {
+        id: { type: 'string', required: true },
+        signerId: { type: 'string', required: true },
+      },
+    );
+    return internalRequest(this.sdk, `/esign/packages/${id}/present`, 'POST', {
+      body: { signerId },
+    });
+  }
+
+  /**
+   * Resend the signing email. Optional `signerId` targets one recipient.
+   * @param {string} id
+   * @param {Object} [params]
+   * @param {string} [params.signerId]
+   * @returns {Promise<Object>}
+   */
+  async remind(id, { signerId } = {}) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+        signerId: { type: 'string', required: false },
+      },
+    );
+    const body = {};
+    if (signerId !== undefined) body.signerId = signerId;
+    return internalRequest(this.sdk, `/esign/packages/${id}/remind`, 'POST', {
+      body,
+    });
+  }
+
+  /**
+   * Void an in-flight package.
+   * @param {string} id
+   * @param {Object} [params]
+   * @param {string} [params.reason]
+   * @returns {Promise<Object>}
+   */
+  async void(id, { reason } = {}) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+        reason: { type: 'string', required: false },
+      },
+    );
+    const body = {};
+    if (reason !== undefined) body.reason = reason;
+    return internalRequest(this.sdk, `/esign/packages/${id}/void`, 'POST', {
+      body,
+    });
+  }
+
+  /**
+   * Idempotent seal repair.
+   * @param {string} id
+   * @returns {Promise<Object>}
+   */
+  async seal(id) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    return internalRequest(this.sdk, `/esign/packages/${id}/seal`, 'POST', {
+      body: {},
+    });
+  }
+
+  /**
+   * Evidence JSON pack.
+   * @param {string} id
+   * @returns {Promise<Object>}
+   */
+  async getEvidence(id) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    return internalRequest(this.sdk, `/esign/packages/${id}/evidence`, 'GET');
+  }
+
+  /**
+   * Package PDF. HTTP-only (binary).
+   * @param {string} id
+   * @param {Object} [params]
+   * @param {string} [params.kind] - `unsigned` | `working` | `sealed` | `certificate`
+   * @returns {Promise<*>} Raw PDF response
+   */
+  async getPdf(id, { kind } = {}) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+        kind: { type: 'string', required: false },
+      },
+    );
+    const params = { returnRawResponse: true };
+    if (kind !== undefined) params.query = { kind };
+    return internalRequest(
+      this.sdk,
+      `/esign/packages/${id}/pdf`,
+      'GET',
+      params,
+      true,
+    );
+  }
+}

package/services/phoneNumbers.js

@@ -651,35 +651,45 @@ export class PhoneNumbersService {
   }
 
   /**
-   * Generate Letter of Authorization (LOA) for a porting order
-   *
-   * Automatically generates a PDF LOA document using template data from the porting order,
-   * uploads it to storage, and attaches it to the order as an LOA document.
+   * Start e-sign for a porting LOA (`send` emails the signer, `present` returns a URL).
    *
    * @param {Object} params
-   * @param {string} params.portingOrderId - Porting order ID to generate LOA for
-   * @param {string} params.signerName - Full name of person signing the LOA
-   * @param {string} params.signerTitle - Job title of person signing the LOA
-   * @returns {Promise<Object>} Generation result with document ID and storage information
+   * @param {string} params.portingOrderId
+   * @param {string} params.signerName
+   * @param {string} params.mode - `send` or `present`
+   * @param {string} [params.signerTitle]
+   * @param {string} [params.signerEmail] - required when mode is send
+   * @returns {Promise<Object>} `{ packageId, status, signers, presentUrl?, presentExpiresAt? }`
    */
-  async generateLoa({ portingOrderId, signerName, signerTitle }) {
+  async generateLoa({
+    portingOrderId,
+    signerName,
+    signerTitle,
+    signerEmail,
+    mode,
+  }) {
     this.sdk.validateParams(
-      { portingOrderId, signerName, signerTitle },
+      { portingOrderId, signerName, mode },
       {
         portingOrderId: { type: 'string', required: true },
         signerName: { type: 'string', required: true },
-        signerTitle: { type: 'string', required: true },
+        mode: { type: 'string', required: true },
+        signerTitle: { type: 'string', required: false },
+        signerEmail: { type: 'string', required: false },
       },
     );
 
-    const result = await internalRequest(this.sdk, 
+    const body = { signerName, mode };
+    if (signerTitle !== undefined) body.signerTitle = signerTitle;
+    if (signerEmail !== undefined) body.signerEmail = signerEmail;
+
+    const result = await internalRequest(
+      this.sdk,
       `/phoneNumbers/porting/orders/${encodeURIComponent(
         portingOrderId,
       )}/generate-loa`,
       'POST',
-      {
-        body: { signerName, signerTitle },
-      },
+      { body },
     );
     return result;
   }

package/services/storage.js

@@ -480,6 +480,7 @@ Response:
     country = 'US',
     expireAfter,
     relatedId,
+    objectName,
     folderId,
     createAccessKey = false,
     accessKeyExpiresIn,
@@ -498,6 +499,7 @@ Response:
         country,
         expireAfter,
         relatedId,
+        objectName,
         folderId,
         createAccessKey,
         accessKeyExpiresIn,
@@ -513,6 +515,7 @@ Response:
         country: { type: 'string', required: false },
         expireAfter: { type: 'string', required: false },
         relatedId: { type: 'string', required: false },
+        objectName: { type: 'string', required: false },
         folderId: { type: 'string', required: false },
         createAccessKey: { type: 'boolean', required: false },
         accessKeyExpiresIn: { type: 'number', required: false },
@@ -530,6 +533,7 @@ Response:
     if (country) formFields.push(['country', country]);
     if (expireAfter) formFields.push(['expireAfter', expireAfter]);
     if (relatedId) formFields.push(['relatedId', relatedId]);
+    if (objectName) formFields.push(['objectName', objectName]);
     if (folderId) formFields.push(['folderId', folderId]);
     if (createAccessKey !== undefined)
       formFields.push(['createAccessKey', createAccessKey.toString()]);
@@ -910,18 +914,20 @@ Response:
    * @param {string} options.name
    * @returns {Promise<Object>}
    */
-  async createFolder({ relatedId, parentId, name } = {}) {
+  async createFolder({ relatedId, parentId, name, objectName } = {}) {
     this.sdk.validateParams(
-      { relatedId, parentId, name },
+      { relatedId, parentId, name, objectName },
       {
         relatedId: { type: 'string', required: true },
         parentId: { type: 'string', required: false },
         name: { type: 'string', required: true },
+        objectName: { type: 'string', required: false },
       },
     );
 
     const body = { relatedId, name };
     if (parentId !== undefined) body.parentId = parentId;
+    if (objectName !== undefined) body.objectName = objectName;
 
     const result = await internalRequest(this.sdk, '/storage/folders', 'POST', {
       body,
@@ -1183,6 +1189,58 @@ Response:
     return result;
   }
 
+  async getAccountSettings() {
+    return internalRequest(this.sdk, '/storage/account-settings', 'GET');
+  }
+
+  async updateAccountSettings(body = {}) {
+    return internalRequest(this.sdk, '/storage/account-settings', 'PUT', {
+      body,
+    });
+  }
+
+  async listRecordSettings() {
+    return internalRequest(this.sdk, '/storage/record-settings', 'GET');
+  }
+
+  async getRecordSettings(objectName) {
+    this.sdk.validateParams(
+      { objectName },
+      { objectName: { type: 'string', required: true } },
+    );
+    return internalRequest(
+      this.sdk,
+      `/storage/record-settings/${objectName}`,
+      'GET',
+    );
+  }
+
+  async updateRecordSettings(objectName, body = {}) {
+    this.sdk.validateParams(
+      { objectName },
+      { objectName: { type: 'string', required: true } },
+    );
+    return internalRequest(
+      this.sdk,
+      `/storage/record-settings/${objectName}`,
+      'PUT',
+      { body },
+    );
+  }
+
+  async getRecordGoogleFolder({ objectName, relatedId } = {}) {
+    this.sdk.validateParams(
+      { objectName, relatedId },
+      {
+        objectName: { type: 'string', required: true },
+        relatedId: { type: 'string', required: true },
+      },
+    );
+    return internalRequest(this.sdk, '/storage/record-google-folders', 'GET', {
+      query: { objectName, relatedId },
+    });
+  }
+
   /**
    * Convert an existing stored file to a different format and save it as a new storage record.
    * The original file remains unchanged. Supported source formats: PDF, DOC, DOCX.