mp-js-api 0.0.29 → 0.0.31

package/dist/utils/converters.js

@@ -9,6 +9,11 @@ exports.toCapitalSnakeCase = toCapitalSnakeCase;
 exports.caseConverter = caseConverter;
 exports.convertToCamelCase = convertToCamelCase;
 exports.convertToSnakeCase = convertToSnakeCase;
+exports.toPascalCase = toPascalCase;
+exports.fromPascalCase = fromPascalCase;
+exports.pascalCaseConverter = pascalCaseConverter;
+exports.convertToPascalCase = convertToPascalCase;
+exports.convertFromPascalCase = convertFromPascalCase;
 function stringifyURLParams(mpOptions = {}) {
     return escapeSql(Object.entries(mpOptions).reduce((acc, [key, value]) => {
         if (!acc) {
@@ -114,3 +119,58 @@ function convertToCamelCase(obj, capitalIds = true) {
 function convertToSnakeCase(obj, capitalIds = true) {
     return caseConverter(obj, { type: 'toSnake', capitalIds });
 }
+/**
+ * Converts a camelCase string to PascalCase.
+ * Example: "authorUserId" → "AuthorUserId"
+ */
+function toPascalCase(str) {
+    if (!str)
+        return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * Converts a PascalCase string to camelCase.
+ * Example: "AuthorUserId" → "authorUserId"
+ */
+function fromPascalCase(str) {
+    if (!str)
+        return str;
+    return str.charAt(0).toLowerCase() + str.slice(1);
+}
+/**
+ * Recursively converts object keys between camelCase and PascalCase.
+ * Used for /communications, /messages, /texts, /procs endpoints.
+ */
+function pascalCaseConverter(obj, direction) {
+    const caseFn = direction === 'toPascal' ? toPascalCase : fromPascalCase;
+    if (Array.isArray(obj)) {
+        return obj.map(val => pascalCaseConverter(val, direction));
+    }
+    if (obj !== null && typeof obj === 'object') {
+        const result = {};
+        for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                const newKey = caseFn(key);
+                result[newKey] = pascalCaseConverter(obj[key], direction);
+            }
+        }
+        return result;
+    }
+    return obj;
+}
+/**
+ * Converts camelCase object keys to PascalCase.
+ * Used for outgoing requests to /communications, /messages, /texts endpoints.
+ * Example: { authorUserId: 1 } → { AuthorUserId: 1 }
+ */
+function convertToPascalCase(obj) {
+    return pascalCaseConverter(obj, 'toPascal');
+}
+/**
+ * Converts PascalCase object keys to camelCase.
+ * Used for incoming responses from /communications, /messages, /texts, /procs endpoints.
+ * Example: { AuthorUserId: 1 } → { authorUserId: 1 }
+ */
+function convertFromPascalCase(obj) {
+    return pascalCaseConverter(obj, 'fromPascal');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mp-js-api",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "description": "Node MinistryPlatform API",
   "main": "dist/index.js",
   "scripts": {

package/src/api.ts

@@ -1,6 +1,10 @@
 import axios, { AxiosError, AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
 import { URLSearchParams } from 'url';
-import { convertToCamelCase, convertToSnakeCase, escapeApostrophes, stringifyURLParams, toCapitalSnakeCase } from './utils/converters';
+import { convertToCamelCase, convertToSnakeCase, convertToPascalCase, convertFromPascalCase, escapeApostrophes, stringifyURLParams, toCapitalSnakeCase } from './utils/converters';
+import { Communication, CommunicationInfo } from './endpoints/communications';
+import { MessageInfo } from './endpoints/messages';
+import { TextInfo } from './endpoints/texts';
+import { ProcedureInfo } from './endpoints/procedures';
 
 
 export type APIGetOneInstance = <T extends Record<string, any>>({ id, path, mpQuery, config }: APIGetParameter & { id: number; }) => Promise<T | undefined | { error: ErrorDetails; }>;
@@ -10,6 +14,15 @@ export type APICreateManyInstance = <T extends Record<string, any>>({ path, mpQu
 export type APICreateFileInstance = <T extends Record<string, any>>({ path, mpQuery, data, config }: APICreateFileParameter) => Promise<T | { error: ErrorDetails; }>;
 export type APIUpdateInstance = <T extends Record<string, any>>({ path, mpQuery, data, config }: APIUpdateParameter) => Promise<T[] | { error: ErrorDetails; }>;
 
+// Communications API types
+export type APISendCommunicationInstance = (data: CommunicationInfo, config?: AxiosRequestConfig) => Promise<Communication | { error: ErrorDetails; }>;
+export type APISendMessageInstance = (data: MessageInfo, config?: AxiosRequestConfig) => Promise<Communication | { error: ErrorDetails; }>;
+export type APISendTextInstance = (data: TextInfo, config?: AxiosRequestConfig) => Promise<Communication | { error: ErrorDetails; }>;
+
+// Procedures API types
+export type APIGetProceduresInstance = (search?: string, config?: AxiosRequestConfig) => Promise<ProcedureInfo[] | { error: ErrorDetails; }>;
+export type APIExecuteProcedureInstance = <T = Record<string, any>>(procedureName: string, input?: Record<string, any>, config?: AxiosRequestConfig) => Promise<T[][] | { error: ErrorDetails; }>;
+
 
 export interface MPApiBase {
   getOne: APIGetOneInstance;
@@ -23,6 +36,13 @@ export interface MPApiBase {
   post: AxiosInstance['post'];
   put: AxiosInstance['put'];
   getError: (error: AxiosError) => ErrorDetails;
+  // Communications API
+  sendCommunication: APISendCommunicationInstance;
+  sendMessage: APISendMessageInstance;
+  sendText: APISendTextInstance;
+  // Procedures API
+  getProcedures: APIGetProceduresInstance;
+  executeProcedure: APIExecuteProcedureInstance;
 }
 
 export interface ErrorDetails {
@@ -183,14 +203,14 @@ export const createApiBase = ({ auth }: { auth: { username: string; password: st
     }
   };
 
-  const createFile: APICreateFileInstance = async <T extends Record<string, any>>({ path, mpQuery, data: payload, config }: APICreateFileParameter) => {
+  const createFile: APICreateFileInstance = async ({ path, mpQuery, data: payload, config }: APICreateFileParameter) => {
     const query = stringifyURLParams(mpQuery);
     // const data = [convertToSnakeCase<Partial<T>>(payload)];
     const data = payload;
     const url = path + query;
     try {
       const res = await post(url, data, config);
-      return convertToCamelCase<T>(res.data[0]);
+      return res.data[0];
     }
     catch (err) {
       return { error: getError(err) };
@@ -226,6 +246,65 @@ export const createApiBase = ({ auth }: { auth: { username: string; password: st
     };
   };
 
+  // Communications API: POST /communications
+  const sendCommunication: APISendCommunicationInstance = async (data, config) => {
+    try {
+      const payload = convertToPascalCase(data);
+      const res = await post<Communication>('/communications', payload, config);
+      return convertFromPascalCase<Communication>(res.data);
+    } catch (err) {
+      return { error: getError(err as AxiosError) };
+    }
+  };
+
+  // Messages API: POST /messages
+  const sendMessage: APISendMessageInstance = async (data, config) => {
+    try {
+      const payload = convertToPascalCase(data);
+      const res = await post<Communication>('/messages', payload, config);
+      return convertFromPascalCase<Communication>(res.data);
+    } catch (err) {
+      return { error: getError(err as AxiosError) };
+    }
+  };
+
+  // Texts API: POST /texts
+  const sendText: APISendTextInstance = async (data, config) => {
+    try {
+      const payload = convertToPascalCase(data);
+      const res = await post<Communication>('/texts', payload, config);
+      return convertFromPascalCase<Communication>(res.data);
+    } catch (err) {
+      return { error: getError(err as AxiosError) };
+    }
+  };
+
+  // Procedures API: GET /procs
+  const getProcedures: APIGetProceduresInstance = async (search, config) => {
+    try {
+      const url = search ? `/procs?$search=${encodeURIComponent(search)}` : '/procs';
+      const res = await get<ProcedureInfo[]>(url, config);
+      return res.data.map(proc => convertFromPascalCase<ProcedureInfo>(proc));
+    } catch (err) {
+      return { error: getError(err as AxiosError) };
+    }
+  };
+
+  // Procedures API: POST /procs/{procedure}
+  const executeProcedure: APIExecuteProcedureInstance = async <T = Record<string, any>>(
+    procedureName: string,
+    input?: Record<string, any>,
+    config?: AxiosRequestConfig
+  ) => {
+    try {
+      const url = `/procs/${encodeURIComponent(procedureName)}`;
+      const res = await post<T[][]>(url, input, config);
+      return res.data;
+    } catch (err) {
+      return { error: getError(err as AxiosError) };
+    }
+  };
+
   return {
     get,
     put,
@@ -237,7 +316,12 @@ export const createApiBase = ({ auth }: { auth: { username: string; password: st
     updateMany,
     createFile,
     updateFile,
-    getError
+    getError,
+    sendCommunication,
+    sendMessage,
+    sendText,
+    getProcedures,
+    executeProcedure,
   };
 };
 

package/src/endpoints/communications.ts

@@ -0,0 +1,125 @@
+/**
+ * Communication type enum.
+ * Determines the delivery method for the communication.
+ */
+export type CommunicationType = 'Unknown' | 'Email' | 'SMS' | 'RssFeed' | 'GlobalMFA';
+
+/**
+ * Communication status enum.
+ * Represents the current state of a communication.
+ */
+export type CommunicationStatus = 'Unknown' | 'Draft' | 'InReview' | 'ReadyToSend' | 'Sent';
+
+/**
+ * Texting compliance level enum.
+ * Controls how bulk opt-out messages are filtered.
+ */
+export type TextingComplianceLevel = 'None' | 'SingleOptIn' | 'DoubleOptIn';
+
+/**
+ * CommunicationInfo - Request payload for POST /communications.
+ * Uses camelCase internally; converted to PascalCase for API.
+ *
+ * API expects: AuthorUserId, FromContactId, CommunicationType, Contacts, etc.
+ */
+export interface CommunicationInfo {
+  /** User ID who authored the communication. */
+  authorUserId: number;
+  /** Subject line of email or SMS/MMS message content. */
+  subject: string;
+  /** Body content of the communication (HTML supported for email). */
+  body?: string;
+  /** Contact ID of the sender. */
+  fromContactId: number;
+  /** Contact ID for replies. */
+  replyToContactId: number;
+  /** Delivery type: 'Email' or 'SMS'. */
+  communicationType: CommunicationType;
+  /** Array of recipient Contact IDs. */
+  contacts: number[];
+  /** ISO datetime to send. Future date = scheduled. */
+  startDate?: string;
+  /** Whether this is a bulk email. */
+  isBulkEmail?: boolean;
+  /** Send to household heads instead of contacts. */
+  sendToContactParents?: boolean;
+  /** Outbound SMS phone number ID (required for SMS). */
+  textPhoneNumberId?: number;
+  /** Exclude contacts who opted out of bulk messages. */
+  excludeOptedOutOfBulkMessages?: boolean;
+  /** Texting compliance filter level (SMS only). */
+  textingComplianceLevel?: TextingComplianceLevel;
+  /** Timezone for date/time rendering in messages. */
+  timeZoneName?: string;
+  /** Locale for value formatting in messages. */
+  cultureName?: string;
+  /** Alternate email type ID. */
+  alternateEmailTypeId?: number;
+  /** Related publication ID. */
+  publicationId?: number;
+}
+
+/**
+ * Communication - Response model from /communications endpoints.
+ * Uses camelCase internally; API returns PascalCase.
+ *
+ * API returns: CommunicationId, AuthorUserId, AuthorName, Subject, etc.
+ */
+export interface Communication {
+  /** Unique identifier of the communication. */
+  communicationId: number;
+  /** User ID who authored the communication. */
+  authorUserId: number;
+  /** Display name of the author (readonly). */
+  authorName: string;
+  /** Subject line or SMS content. */
+  subject: string;
+  /** Body content. */
+  body?: string;
+  /** Start/send date. */
+  startDate: string;
+  /** Expiration date. */
+  expirationDate?: string;
+  /** Current status. */
+  status?: CommunicationStatus;
+  /** Sender contact ID. */
+  fromContactId: number;
+  /** Sender display name (readonly). */
+  fromName: string;
+  /** Sender email address (readonly). */
+  fromAddress: string;
+  /** Reply-to contact ID. */
+  replyToContactId: number;
+  /** Reply-to display name (readonly). */
+  replyToName: string;
+  /** Reply-to email address (readonly). */
+  replyToAddress: string;
+  /** Associated task ID. */
+  taskId?: number;
+  /** Selection ID for recipients. */
+  selectionId?: number;
+  /** Single recipient contact ID override. */
+  recipientContactId?: number;
+  /** Recipient display name (readonly). */
+  recipientName?: string;
+  /** Send to household heads. */
+  sendToContactParents?: boolean;
+  /** Exclude opted-out contacts. */
+  excludeOptedOutOfBulkMessages?: boolean;
+  /** Texting compliance level. */
+  textingComplianceLevel?: TextingComplianceLevel;
+  /** Timezone for rendering. */
+  timeZoneName?: string;
+  /** Locale for formatting. */
+  cultureName?: string;
+  /** Outbound SMS phone number ID. */
+  textPhoneNumberId?: number;
+  /** Outbound SMS phone number (readonly). */
+  textPhoneNumber?: string;
+  /** Communication delivery type. */
+  communicationType: CommunicationType;
+  /** Alternate email type ID. */
+  alternateEmailTypeId?: number;
+  /** Related publication ID. */
+  publicationId?: number;
+}

package/src/endpoints/messages.ts

@@ -0,0 +1,34 @@
+/**
+ * MessageAddress - Email address with display name.
+ * Used for FromAddress, ToAddresses, and ReplyToAddress.
+ *
+ * API expects/returns: DisplayName, Address (PascalCase)
+ */
+export interface MessageAddress {
+  /** Display name shown in email client. */
+  displayName: string;
+  /** Email address. */
+  address: string;
+}
+
+/**
+ * MessageInfo - Request payload for POST /messages.
+ * Sends emails directly by email address (bypasses MP contacts).
+ * Uses camelCase internally; converted to PascalCase for API.
+ *
+ * API expects: FromAddress, ToAddresses, ReplyToAddress, Subject, Body, StartDate
+ */
+export interface MessageInfo {
+  /** Sender email address and display name. */
+  fromAddress: MessageAddress;
+  /** Array of recipient email addresses. */
+  toAddresses: MessageAddress[];
+  /** Reply-to email address (optional). */
+  replyToAddress?: MessageAddress;
+  /** Email subject line. */
+  subject: string;
+  /** Email body content (HTML supported). */
+  body: string;
+  /** ISO datetime to send. Future date = scheduled. */
+  startDate?: string;
+}

package/src/endpoints/procedures.ts

@@ -0,0 +1,87 @@
+/**
+ * Parameter direction enum.
+ * Indicates whether a parameter is input, output, or both.
+ */
+export type ParameterDirection = 'Input' | 'Output' | 'InputOutput' | 'ReturnValue';
+
+/**
+ * Parameter data type enum.
+ * All supported SQL data types for stored procedure parameters.
+ */
+export type ParameterDataType =
+  | 'Unknown'
+  | 'String'
+  | 'Text'
+  | 'Xml'
+  | 'Byte'
+  | 'Integer16'
+  | 'Integer32'
+  | 'Integer64'
+  | 'Decimal'
+  | 'Real'
+  | 'Boolean'
+  | 'Date'
+  | 'Time'
+  | 'DateTime'
+  | 'Timestamp'
+  | 'Binary'
+  | 'Password'
+  | 'Money'
+  | 'Guid'
+  | 'Phone'
+  | 'Email'
+  | 'Variant'
+  | 'Separator'
+  | 'Image'
+  | 'Counter'
+  | 'TableName'
+  | 'GlobalFilter'
+  | 'TimeZone'
+  | 'Locale'
+  | 'LargeString'
+  | 'Url'
+  | 'Strings'
+  | 'Integers'
+  | 'Color'
+  | 'SecretKey';
+
+/**
+ * ParameterInfo - Metadata about a stored procedure parameter.
+ * Uses camelCase internally; API returns PascalCase.
+ *
+ * API returns: Name, Direction, DataType, Size
+ */
+export interface ParameterInfo {
+  /** Parameter name (e.g., "@ContactId"). */
+  name: string;
+  /** Parameter direction (Input, Output, etc.). */
+  direction: ParameterDirection;
+  /** SQL data type. */
+  dataType: ParameterDataType;
+  /** Maximum length/size. */
+  size: number;
+}
+
+/**
+ * ProcedureInfo - Metadata about a stored procedure.
+ * Returned from GET /procs endpoint.
+ * Uses camelCase internally; API returns PascalCase.
+ *
+ * API returns: Name, Parameters
+ */
+export interface ProcedureInfo {
+  /** Procedure name (e.g., "api_Custom_GetContacts"). */
+  name: string;
+  /** Array of parameter definitions. */
+  parameters: ParameterInfo[];
+}
+
+/**
+ * ProcedureInput - Input parameters for executing a stored procedure.
+ * Keys should match parameter names with @ prefix.
+ *
+ * Example: { "@SelectionID": 26918, "@StartDate": "2024-01-01" }
+ */
+export interface ProcedureInput {
+  [parameterName: string]: string | number | boolean | null;
+}

package/src/endpoints/texts.ts

@@ -0,0 +1,17 @@
+/**
+ * TextInfo - Request payload for POST /texts.
+ * Sends SMS/MMS messages to phone numbers.
+ * Uses camelCase internally; converted to PascalCase for API.
+ *
+ * API expects: FromPhoneNumberId, ToPhoneNumbers, Message, StartDate
+ */
+export interface TextInfo {
+  /** MP phone number ID for outbound messages. */
+  fromPhoneNumberId: number;
+  /** Array of recipient phone numbers in E.164 format (e.g., "+15551234567"). */
+  toPhoneNumbers: string[];
+  /** Message content (SMS character limits apply). */
+  message: string;
+  /** ISO datetime to send. Future date = scheduled. */
+  startDate?: string;
+}

package/src/index.ts

@@ -1,7 +1,11 @@
-import { AxiosInstance } from 'axios';
+import { AxiosInstance, AxiosRequestConfig } from 'axios';
 import { createApiBase, MPApiBase, ErrorDetails, MPGetQuery, MPCreateQuery, MPUpdateQuery, DateTimeIsoString } from './api';
-import { convertToCamelCase, convertToSnakeCase, escapeSql, stringifyURLParams } from './utils/converters';
+import { convertToCamelCase, convertToSnakeCase, convertToPascalCase, convertFromPascalCase, escapeSql, stringifyURLParams } from './utils/converters';
 import { Contact, ContactRecord } from './tables/contacts';
+import { Communication, CommunicationInfo, CommunicationType, CommunicationStatus, TextingComplianceLevel } from './endpoints/communications';
+import { MessageInfo, MessageAddress } from './endpoints/messages';
+import { TextInfo } from './endpoints/texts';
+import { ProcedureInfo, ParameterInfo, ParameterDirection, ParameterDataType, ProcedureInput } from './endpoints/procedures';
 import { Event, EventRecord } from './tables/events';
 import { Group, GroupRecord } from './tables/groups';
 import { Address, AddressRecord } from './tables/addresses';
@@ -64,6 +68,20 @@ export type CreateFilePayload = WithRequired<
   'Description' | 'IsDefaultImage'
 >;
 
+// Communications API payload types
+export type CreateCommunicationPayload = WithRequired<
+  CommunicationInfo,
+  'authorUserId' | 'subject' | 'fromContactId' | 'replyToContactId' | 'communicationType' | 'contacts'
+>;
+export type CreateMessagePayload = WithRequired<
+  MessageInfo,
+  'fromAddress' | 'toAddresses' | 'subject' | 'body'
+>;
+export type CreateTextPayload = WithRequired<
+  TextInfo,
+  'fromPhoneNumberId' | 'toPhoneNumbers' | 'message'
+>;
+
 
 export interface ContactDetails extends Contact, Participant, Household {
   householdID: number;
@@ -240,16 +258,45 @@ export type MPInstance = {
 
   getFiles(table: string, recordId: number, mpQuery?: MPGetQuery)
     : Promise<AttachedFile[] | { error: ErrorDetails; }>;
-  uploadFiles(table: string, recordId: number, data: CreateFilePayload[])
+  uploadFile(table: string, recordId: number, data: FormData)
     : Promise<AttachedFile | { error: ErrorDetails; }>;
   updateFiles(table: string, fileId: number, data: WithRequired<Partial<AttachedFile>, 'FileId'>[])
     : Promise<AttachedFile[] | { error: ErrorDetails; }>;
+
+  // Communications API
+  sendCommunication(
+    data: CreateCommunicationPayload,
+    config?: AxiosRequestConfig
+  ): Promise<Communication | { error: ErrorDetails; }>;
+  sendMessage(
+    data: CreateMessagePayload,
+    config?: AxiosRequestConfig
+  ): Promise<Communication | { error: ErrorDetails; }>;
+  sendText(
+    data: CreateTextPayload,
+    config?: AxiosRequestConfig
+  ): Promise<Communication | { error: ErrorDetails; }>;
+
+  // Procedures API
+  getProcedures(
+    search?: string,
+    config?: AxiosRequestConfig
+  ): Promise<ProcedureInfo[] | { error: ErrorDetails; }>;
+  executeProcedure<T = Record<string, any>>(
+    procedureName: string,
+    input?: ProcedureInput,
+    config?: AxiosRequestConfig
+  ): Promise<T[][] | { error: ErrorDetails; }>;
 };
 
 
 export const createMPInstance = ({ auth }: { auth: { username: string; password: string; }; }): MPInstance => {
 
-  const { getOne, getMany, createOne, createMany, updateMany, createFile, updateFile, get, post, put } = createApiBase({ auth });
+  const {
+    getOne, getMany, createOne, createMany, updateMany, createFile, updateFile,
+    get, post, put,
+    sendCommunication, sendMessage, sendText, getProcedures, executeProcedure
+  } = createApiBase({ auth });
 
   return {
     get,
@@ -484,7 +531,7 @@ export const createMPInstance = ({ auth }: { auth: { username: string; password:
         { path: `/files/${table}/${recordId}`, mpQuery: {} }
       );
     },
-    async uploadFiles(table, recordId, data) {
+    async uploadFile(table, recordId, data) {
       return createFile<AttachedFile>(
         { path: `/files/${table}/${recordId}`, data }
       );
@@ -494,10 +541,20 @@ export const createMPInstance = ({ auth }: { auth: { username: string; password:
         { path: `/files/${table}/${fileId}`, data }
       );
     },
+
+    // Communications API
+    sendCommunication,
+    sendMessage,
+    sendText,
+
+    // Procedures API
+    getProcedures,
+    executeProcedure,
   };
 };
 
 export {
+  // Tables
   Contact,
   Participant,
   Event,
@@ -513,10 +570,31 @@ export {
   ContactEmailAddress,
   ContactWithEmailAddress,
   ContactWithEmailAddresses,
+
+  // Communications endpoint types
+  Communication,
+  CommunicationInfo,
+  CommunicationType,
+  CommunicationStatus,
+  TextingComplianceLevel,
+  MessageInfo,
+  MessageAddress,
+  TextInfo,
+
+  // Procedures endpoint types
+  ProcedureInfo,
+  ParameterInfo,
+  ParameterDirection,
+  ParameterDataType,
+  ProcedureInput,
+
+  // Utilities
   ErrorDetails,
   DateTimeIsoString,
   convertToCamelCase,
   convertToSnakeCase,
+  convertToPascalCase,
+  convertFromPascalCase,
   stringifyURLParams,
   escapeSql
 };

package/src/utils/converters.ts

@@ -114,3 +114,67 @@ export function convertToCamelCase<T extends Record<string, any> = Record<string
 export function convertToSnakeCase<T extends Record<string, any> = Record<string, any>, D extends Record<string, any> = Record<string, any>>(obj: Partial<D>, capitalIds = true): T {
   return caseConverter(obj, { type: 'toSnake', capitalIds });
 }
+
+/**
+ * Converts a camelCase string to PascalCase.
+ * Example: "authorUserId" → "AuthorUserId"
+ */
+export function toPascalCase(str: string): string {
+  if (!str) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+/**
+ * Converts a PascalCase string to camelCase.
+ * Example: "AuthorUserId" → "authorUserId"
+ */
+export function fromPascalCase(str: string): string {
+  if (!str) return str;
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+
+/**
+ * Recursively converts object keys between camelCase and PascalCase.
+ * Used for /communications, /messages, /texts, /procs endpoints.
+ */
+export function pascalCaseConverter<T>(
+  obj: T,
+  direction: 'toPascal' | 'fromPascal'
+): T {
+  const caseFn = direction === 'toPascal' ? toPascalCase : fromPascalCase;
+
+  if (Array.isArray(obj)) {
+    return obj.map(val => pascalCaseConverter(val, direction)) as T;
+  }
+
+  if (obj !== null && typeof obj === 'object') {
+    const result: Record<string, unknown> = {};
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        const newKey = caseFn(key);
+        result[newKey] = pascalCaseConverter((obj as Record<string, unknown>)[key], direction);
+      }
+    }
+    return result as T;
+  }
+
+  return obj;
+}
+
+/**
+ * Converts camelCase object keys to PascalCase.
+ * Used for outgoing requests to /communications, /messages, /texts endpoints.
+ * Example: { authorUserId: 1 } → { AuthorUserId: 1 }
+ */
+export function convertToPascalCase<T extends Record<string, any>>(obj: T): T {
+  return pascalCaseConverter(obj, 'toPascal');
+}
+
+/**
+ * Converts PascalCase object keys to camelCase.
+ * Used for incoming responses from /communications, /messages, /texts, /procs endpoints.
+ * Example: { AuthorUserId: 1 } → { authorUserId: 1 }
+ */
+export function convertFromPascalCase<T extends Record<string, any>>(obj: T): T {
+  return pascalCaseConverter(obj, 'fromPascal');
+}