@memberjunction/server 6.2.0-edge.0 → 6.2.0-edge.1

package/src/resolvers/adhoc-query-helpers.ts

@@ -15,7 +15,7 @@
  * - **Full page** (`pageLength >= maxRows`): more rows may exist — returns `null` to
  *   signal that a `COUNT(*)` is required to know the true total.
  */
-export function exactTotalFromPage(
+export function ExactTotalFromPage(
     startRow: number,
     pageLength: number,
     maxRows: number | null,
@@ -29,13 +29,22 @@ export function exactTotalFromPage(
     return null;
 }
 
+/** @deprecated Use {@link ExactTotalFromPage}. */
+export function exactTotalFromPage(
+    startRow: number,
+    pageLength: number,
+    maxRows: number | null,
+): number | null {
+    return ExactTotalFromPage(startRow, pageLength, maxRows);
+}
+
 /**
  * Reads the total row count from a `COUNT(*)` recordset (`[{ TotalRowCount }]`),
  * falling back to `fallback` when the count is absent, non-numeric, or negative — so
  * an unexpected count shape never yields a misleading total. `fallback` should be a
  * safe lower bound (e.g. `startRow + rowsReturned`).
  */
-export function resolveAdhocTotalRowCount(
+export function ResolveAdhocTotalRowCount(
     countRows: ReadonlyArray<{ TotalRowCount?: unknown }> | null | undefined,
     fallback: number,
 ): number {
@@ -48,3 +57,11 @@ export function resolveAdhocTotalRowCount(
     }
     return fallback;
 }
+
+/** @deprecated Use {@link ResolveAdhocTotalRowCount}. */
+export function resolveAdhocTotalRowCount(
+    countRows: ReadonlyArray<{ TotalRowCount?: unknown }> | null | undefined,
+    fallback: number,
+): number {
+    return ResolveAdhocTotalRowCount(countRows, fallback);
+}

package/src/resolvers/artifact-routing.ts

@@ -12,38 +12,38 @@ export type ArtifactDeliveryMode = 'Inline' | 'ToolsOnly';
 
 export interface ArtifactRoutingInput {
     /** The Artifact Type's DefaultDeliveryMode. */
-    typeDefault: ArtifactDeliveryMode;
+    TypeDefault: ArtifactDeliveryMode;
     /** Per-instance opt-out — `true` forces tools regardless of typeDefault. */
-    forceToolsOnly: boolean;
+    ForceToolsOnly: boolean;
     /** MIME type of the artifact content (e.g. 'image/png'). */
-    mimeType: string;
+    mimeType: string;  // case-violation-ok-legacy-back-compat: the old name is also read off a value typed `any`, where a rename would compile and silently return undefined
     /** Size of the content in bytes. */
-    sizeBytes: number;
+    SizeBytes: number;
     /** Maximum inline size in bytes; over this, even Inline-default artifacts go to tools. */
-    inlineSizeCap: number;
+    InlineSizeCap: number;
     /** Predicate: does the active model driver support the given MIME modality inline? */
-    modelSupportsModality: (mimeType: string) => boolean;
+    ModelSupportsModality: (mimeType: string) => boolean;
     /** Model name used in error messages — never used to make decisions. */
-    modelName: string;
+    ModelName: string;
     /** Artifact type name used in error messages. */
-    artifactTypeName: string;
+    ArtifactTypeName: string;
 }
 
 export type ArtifactRoutingDecision =
-    | { delivery: 'inline' }
-    | { delivery: 'tools'; annotation?: string }
-    | { delivery: 'error'; message: string };
+    | { delivery: 'inline' }  // case-violation-ok-legacy-back-compat: the old name is also read off a value typed `any`, where a rename would compile and silently return undefined
+    | { delivery: 'tools'; Annotation?: string }  // case-violation-ok-legacy-back-compat: the old name is also read off a value typed `any`, where a rename would compile and silently return undefined
+    | { delivery: 'error'; message: string };  // case-violation-ok-legacy-back-compat: the old name is also read off a value typed `any`, where a rename would compile and silently return undefined
 
 export function RouteArtifact(input: ArtifactRoutingInput): ArtifactRoutingDecision {
     const {
-        typeDefault,
-        forceToolsOnly,
+        TypeDefault: typeDefault,
+        ForceToolsOnly: forceToolsOnly,
         mimeType,
-        sizeBytes,
-        inlineSizeCap,
-        modelSupportsModality,
-        modelName,
-        artifactTypeName,
+        SizeBytes: sizeBytes,
+        InlineSizeCap: inlineSizeCap,
+        ModelSupportsModality: modelSupportsModality,
+        ModelName: modelName,
+        ArtifactTypeName: artifactTypeName,
     } = input;
 
     // Path 1: ToolsOnly default or per-instance opt-out — always tools.
@@ -71,7 +71,7 @@ export function RouteArtifact(input: ArtifactRoutingInput): ArtifactRoutingDecis
     if (sizeBytes >= inlineSizeCap) {
         return {
             delivery: 'tools',
-            annotation: `Artifact type "${artifactTypeName}" is configured for Inline delivery but content size (${sizeBytes} bytes) exceeds the inline cap (${inlineSizeCap} bytes); delivered via tools instead.`,
+            Annotation: `Artifact type "${artifactTypeName}" is configured for Inline delivery but content size (${sizeBytes} bytes) exceeds the inline cap (${inlineSizeCap} bytes); delivered via tools instead.`,
         };
     }
 

package/src/resolvers/meetingRecordingRegistration.ts

@@ -81,13 +81,13 @@ export interface MeetingRecordingRegistrationConfig {
    * The `MJ: File Storage Providers` id whose accounts target the egress sink (where LiveKit wrote the
    * MP4). Falls back to `process.env.MJ_MEETING_RECORDING_STORAGE_PROVIDER`.
    */
-  sinkStorageProviderID?: string;
+  SinkStorageProviderID?: string;
   /**
    * OPTIONAL canonical provider id — when set AND different from the sink, the MP4 is copied into it and
    * the Files row points there (the "copy into Box" option). Falls back to
    * `process.env.MJ_MEETING_RECORDING_CANONICAL_STORAGE_PROVIDER`. OFF by default.
    */
-  canonicalStorageProviderID?: string;
+  CanonicalStorageProviderID?: string;
 }
 
 /**
@@ -100,7 +100,7 @@ export interface MeetingRecordingRegistrationConfig {
  * @param provider The metadata provider servicing this request.
  * @param config Optional config overrides (otherwise read from env).
  */
-export async function registerMeetingRecordingFile(
+export async function RegisterMeetingRecordingFile(
   egress: MeetingRecordingEgressResult,
   contextUser: UserInfo,
   provider: IMetadataProvider,
@@ -115,7 +115,7 @@ export async function registerMeetingRecordingFile(
       };
     }
 
-    const sinkProviderID = config?.sinkStorageProviderID ?? process.env.MJ_MEETING_RECORDING_STORAGE_PROVIDER;
+    const sinkProviderID = config?.SinkStorageProviderID ?? process.env.MJ_MEETING_RECORDING_STORAGE_PROVIDER;
     if (!sinkProviderID) {
       return {
         Success: false,
@@ -138,7 +138,7 @@ export async function registerMeetingRecordingFile(
       };
     }
 
-    const conversationID = await resolveMeetingConversation(egress, contextUser, provider);
+    const conversationID = await ResolveMeetingConversation(egress, contextUser, provider);
     if (!conversationID) {
       return { Success: false, ErrorMessage: 'Could not resolve or create the Meeting-Room Conversation for the recording.' };
     }
@@ -175,6 +175,16 @@ export async function registerMeetingRecordingFile(
   }
 }
 
+/** @deprecated Use {@link RegisterMeetingRecordingFile}. */
+export async function registerMeetingRecordingFile(
+  egress: MeetingRecordingEgressResult,
+  contextUser: UserInfo,
+  provider: IMetadataProvider,
+  config?: MeetingRecordingRegistrationConfig,
+): Promise<MeetingRecordingRegistrationResult> {
+  return RegisterMeetingRecordingFile(egress, contextUser, provider, config);
+}
+
 /**
  * Best-effort correlation when a recording STARTS: stamps `Conversation.EgressID` onto the room's
  * Meeting-Room Conversation (if it already exists) so a live recording is tracked against the room. If the
@@ -187,7 +197,7 @@ export async function registerMeetingRecordingFile(
  * @param provider The metadata provider.
  * @returns `true` when an existing conversation was stamped, else `false`.
  */
-export async function correlateRecordingStart(roomName: string, egressID: string, contextUser: UserInfo, provider: IMetadataProvider): Promise<boolean> {
+export async function CorrelateRecordingStart(roomName: string, egressID: string, contextUser: UserInfo, provider: IMetadataProvider): Promise<boolean> {
   try {
     const conversationID = await findConversationByRoomName(roomName, contextUser, provider);
     if (!conversationID) {
@@ -210,12 +220,17 @@ export async function correlateRecordingStart(roomName: string, egressID: string
   }
 }
 
+/** @deprecated Use {@link CorrelateRecordingStart}. */
+export async function correlateRecordingStart(roomName: string, egressID: string, contextUser: UserInfo, provider: IMetadataProvider): Promise<boolean> {
+  return CorrelateRecordingStart(roomName, egressID, contextUser, provider);
+}
+
 /**
  * Resolves the Meeting-Room Conversation for a completed recording: prefer matching by `EgressID` (set on
  * start), fall back to the room name (`ExternalID` + `Type`), else create one following the transcript
  * sink's pattern (scoped `Application` so it stays out of the normal chat list).
  */
-export async function resolveMeetingConversation(
+export async function ResolveMeetingConversation(
   egress: MeetingRecordingEgressResult,
   contextUser: UserInfo,
   provider: IMetadataProvider,
@@ -231,6 +246,15 @@ export async function resolveMeetingConversation(
   return createMeetingConversation(egress.RoomName, contextUser, provider);
 }
 
+/** @deprecated Use {@link ResolveMeetingConversation}. */
+export async function resolveMeetingConversation(
+  egress: MeetingRecordingEgressResult,
+  contextUser: UserInfo,
+  provider: IMetadataProvider,
+): Promise<string | null> {
+  return ResolveMeetingConversation(egress, contextUser, provider);
+}
+
 /** Finds a non-archived Meeting-Room Conversation by its `EgressID`. */
 async function findConversationByEgressID(egressID: string, contextUser: UserInfo, provider: IMetadataProvider): Promise<string | null> {
   if (!egressID) {
@@ -310,7 +334,7 @@ async function resolveFileLocation(
   config?: MeetingRecordingRegistrationConfig,
 ): Promise<FileLocationResult> {
   const outputLocation = egress.OutputLocation!;
-  const canonicalProviderID = config?.canonicalStorageProviderID ?? process.env.MJ_MEETING_RECORDING_CANONICAL_STORAGE_PROVIDER;
+  const canonicalProviderID = config?.CanonicalStorageProviderID ?? process.env.MJ_MEETING_RECORDING_CANONICAL_STORAGE_PROVIDER;
 
   // Default (v1): point directly at the sink output — playback streams straight from it, no byte copy.
   if (!canonicalProviderID || canonicalProviderID === sinkProviderID) {
@@ -319,7 +343,7 @@ async function resolveFileLocation(
 
   // OPTIONAL "copy into Box": a separate canonical provider IS configured and differs from the sink —
   // read the bytes from the sink and upload them into the canonical provider, then point there.
-  const canonicalKey = await copyEgressOutputToCanonical(outputLocation, sinkAccountID, canonicalProviderID, contextUser);
+  const canonicalKey = await CopyEgressOutputToCanonical(outputLocation, sinkAccountID, canonicalProviderID, contextUser);
   if (!canonicalKey.Success) {
     return { Success: false, ErrorMessage: canonicalKey.ErrorMessage, ProviderID: '', ProviderKey: '' };
   }
@@ -338,7 +362,7 @@ interface CanonicalCopyResult {
  * into Box" option). Reads the bytes via the sink driver's `GetObject({ fullPath })` and re-uploads them
  * into the canonical provider via `FileStorageEngine.UploadFile`. Returns the canonical `ProviderKey`.
  */
-export async function copyEgressOutputToCanonical(
+export async function CopyEgressOutputToCanonical(
   outputLocation: string,
   sinkAccountID: string,
   canonicalProviderID: string,
@@ -369,6 +393,16 @@ export async function copyEgressOutputToCanonical(
   return { Success: true, ProviderKey: uploaded.StoragePath };
 }
 
+/** @deprecated Use {@link CopyEgressOutputToCanonical}. */
+export async function copyEgressOutputToCanonical(
+  outputLocation: string,
+  sinkAccountID: string,
+  canonicalProviderID: string,
+  contextUser: UserInfo,
+): Promise<CanonicalCopyResult> {
+  return CopyEgressOutputToCanonical(outputLocation, sinkAccountID, canonicalProviderID, contextUser);
+}
+
 /** Creates the `MJ: Files` row pointing at the recording (no byte copy in the default v1 path). */
 async function createRecordingFileRow(
   egress: MeetingRecordingEgressResult,

package/src/resolvers/peaksSidecar.ts

@@ -15,7 +15,7 @@
  * @example deriveSidecarPath('realtime-recordings/sess-1/recording.wav') === 'realtime-recordings/sess-1/peaks.json'
  * @example deriveSidecarPath('recording.wav') === 'peaks.json'
  */
-export function deriveSidecarPath(providerKey: string | null | undefined): string | null {
+export function DeriveSidecarPath(providerKey: string | null | undefined): string | null {
     if (!providerKey) {
         return null;
     }
@@ -23,6 +23,11 @@ export function deriveSidecarPath(providerKey: string | null | undefined): strin
     return lastSlash >= 0 ? `${providerKey.slice(0, lastSlash)}/peaks.json` : 'peaks.json';
 }
 
+/** @deprecated Use {@link DeriveSidecarPath}. */
+export function deriveSidecarPath(providerKey: string | null | undefined): string | null {
+    return DeriveSidecarPath(providerKey);
+}
+
 /** Generous ceiling on the number of peaks returned — matches the capture-side cap. */
 export const MAX_PEAKS = 4096;
 
@@ -35,7 +40,7 @@ export const MAX_PEAKS = 4096;
  * @param bytes The raw sidecar bytes (e.g. from a storage `GetObject`).
  * @returns Sanitized `0..1` peaks, or `undefined`.
  */
-export function parsePeaksSidecar(bytes: Buffer): number[] | undefined {
+export function ParsePeaksSidecar(bytes: Buffer): number[] | undefined {
     try {
         const parsed: unknown = JSON.parse(bytes.toString('utf8'));
         if (!Array.isArray(parsed) || parsed.length === 0) {
@@ -50,3 +55,8 @@ export function parsePeaksSidecar(bytes: Buffer): number[] | undefined {
         return undefined;
     }
 }
+
+/** @deprecated Use {@link ParsePeaksSidecar}. */
+export function parsePeaksSidecar(bytes: Buffer): number[] | undefined {
+    return ParsePeaksSidecar(bytes);
+}

package/src/rest/EntityCRUDHandler.ts

@@ -11,7 +11,7 @@ export class EntityCRUDHandler {
     /**
      * Create a new entity
      */
-    static async createEntity(entityName: string, data: any, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string, details?: any, validationErrors?: any[] }> {
+    static async CreateEntity(entityName: string, data: any, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string, details?: any, validationErrors?: any[] }> {
         try {
             // Get entity object
             const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
@@ -77,11 +77,16 @@ export class EntityCRUDHandler {
             return { success: false, error: error?.message || 'Unknown error' };
         }
     }
+
+    /** @deprecated Use {@link CreateEntity}. */
+    static async createEntity(entityName: string, data: any, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string, details?: any, validationErrors?: any[] }> {
+        return this.CreateEntity(entityName, data, user);
+    }
     
     /**
      * Read an entity by ID
      */
-    static async getEntity(entityName: string, id: string | number, relatedEntities: string[] = null, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string }> {
+    static async GetEntity(entityName: string, id: string | number, relatedEntities: string[] = null, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string }> {
         try {
             // Get entity object
             const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
@@ -116,11 +121,16 @@ export class EntityCRUDHandler {
             return { success: false, error: error?.message || 'Unknown error' };
         }
     }
+
+    /** @deprecated Use {@link GetEntity}. */
+    static async getEntity(entityName: string, id: string | number, relatedEntities: string[] = null, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string }> {
+        return this.GetEntity(entityName, id, relatedEntities, user);
+    }
     
     /**
      * Update an existing entity
      */
-    static async updateEntity(entityName: string, id: string | number, data: any, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string, details?: any, validationErrors?: any[] }> {
+    static async UpdateEntity(entityName: string, id: string | number, data: any, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string, details?: any, validationErrors?: any[] }> {
         try {
             // Get entity object
             const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
@@ -203,11 +213,16 @@ export class EntityCRUDHandler {
             return { success: false, error: error?.message || 'Unknown error' };
         }
     }
+
+    /** @deprecated Use {@link UpdateEntity}. */
+    static async updateEntity(entityName: string, id: string | number, data: any, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string, details?: any, validationErrors?: any[] }> {
+        return this.UpdateEntity(entityName, id, data, user);
+    }
     
     /**
      * Delete an entity
      */
-    static async deleteEntity(entityName: string, id: string | number, options: EntityDeleteOptions, user: UserInfo): Promise<{ success: boolean, error?: string, details?: any }> {
+    static async DeleteEntity(entityName: string, id: string | number, options: EntityDeleteOptions, user: UserInfo): Promise<{ success: boolean, error?: string, details?: any }> {
         try {
             // Get entity object
             const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
@@ -252,6 +267,11 @@ export class EntityCRUDHandler {
             return { success: false, error: error?.message || 'Unknown error' };
         }
     }
+
+    /** @deprecated Use {@link DeleteEntity}. */
+    static async deleteEntity(entityName: string, id: string | number, options: EntityDeleteOptions, user: UserInfo): Promise<{ success: boolean, error?: string, details?: any }> {
+        return this.DeleteEntity(entityName, id, options, user);
+    }
     
     /**
      * Build the record key from the `:id` path segment. A single-column key (any column name) is

package/src/rest/MediaStreamHandler.ts

@@ -23,10 +23,10 @@ import { LogError, Metadata, UserInfo } from '@memberjunction/core';
 import { MJFileEntity } from '@memberjunction/core-entities';
 import { FileStorageEngine } from '@memberjunction/storage';
 import type { FileStorageBase, ByteRange } from '@memberjunction/storage';
-import { getSystemUser } from '../auth/index.js';
+import { GetSystemUser } from '../auth/index.js';
 import { MediaAccessKeyManager } from './MediaAccessKeys.js';
 import { UploadTokenManager } from './UploadTokenManager.js';
-import { parseRange, parseRangeHeaderLoose } from './mediaRange.js';
+import { ParseRange, ParseRangeHeaderLoose } from './mediaRange.js';
 
 /** A located bytes source for a file: the driver + the provider key to read. */
 interface FileBytesSource {
@@ -41,7 +41,7 @@ interface FileBytesSource {
  * - `GET /media/:fileId` and `GET /media/:fileId/:filename` (Range streaming)
  * - `POST /media/upload-stage` (Raw binary upload staging)
  */
-export function createMediaStreamRouter(): Router {
+export function CreateMediaStreamRouter(): Router {
   const router = express.Router();
 
   router.post(
@@ -61,6 +61,11 @@ export function createMediaStreamRouter(): Router {
   return router;
 }
 
+/** @deprecated Use {@link CreateMediaStreamRouter}. */
+export function createMediaStreamRouter(): Router {
+  return CreateMediaStreamRouter();
+}
+
 /**
  * Authenticated raw binary upload staging handler (`POST /media/upload-stage`).
  *
@@ -203,7 +208,7 @@ function verifyMediaToken(token: string, fileId: string): { fileId: string; user
  * provider indistinguishable from a deleted file.
  */
 async function resolveFileBytesSource(fileId: string): Promise<FileBytesSource | null> {
-  const systemUser: UserInfo = await getSystemUser();
+  const systemUser: UserInfo = await GetSystemUser();
 
   // The /media route runs pre-auth on the server's own provider; access was already authorized
   // at token-mint time, so this load only locates the bytes.
@@ -261,7 +266,7 @@ async function streamOrBuffer(req: Request, res: Response, source: FileBytesSour
 
 /** True-streaming path: `GetObjectStream` + pipe, with 206 when a Range was honored. */
 async function serveViaStream(res: Response, source: FileBytesSource, rangeHeader: string | undefined): Promise<void> {
-  const range = rangeHeader ? parseRangeHeaderLoose(rangeHeader) : undefined;
+  const range = rangeHeader ? ParseRangeHeaderLoose(rangeHeader) : undefined;
   // Omit End for an open-ended range so the driver streams to EOF (per ByteRange semantics).
   const streamRange: ByteRange | undefined = range
     ? (range.end == null ? { Start: range.start } : { Start: range.start, End: range.end })
@@ -315,7 +320,7 @@ async function serveViaBuffer(res: Response, source: FileBytesSource, rangeHeade
     return;
   }
 
-  const range = parseRange(rangeHeader, total);
+  const range = ParseRange(rangeHeader, total);
   if (!range) {
     // Unsatisfiable range — per RFC 7233, 416 + Content-Range with the total size.
     res.setHeader('Content-Range', `bytes */${total}`);

package/src/rest/OAuthCallbackHandler.ts

@@ -33,11 +33,11 @@ const ENTITY_OAUTH_AUTHORIZATION_STATES = 'MJ: O Auth Authorization States';
  */
 export interface OAuthCallbackHandlerOptions {
     /** Base URL for this MJAPI instance (for redirects) */
-    publicUrl: string;
+    publicUrl: string;  // case-violation-ok-legacy-back-compat: renaming it broke a use the checker could not see from the declaration — the compile proved it
     /** URL to redirect to after successful authorization */
-    successRedirectUrl?: string;
+    successRedirectUrl?: string;  // case-violation-ok-legacy-back-compat: renaming it broke a use the checker could not see from the declaration — the compile proved it
     /** URL to redirect to after failed authorization */
-    errorRedirectUrl?: string;
+    errorRedirectUrl?: string;  // case-violation-ok-legacy-back-compat: renaming it broke a use the checker could not see from the declaration — the compile proved it
     /**
      * Origins a caller-supplied `frontendReturnUrl` is allowed to point at, so the OAuth callback
      * cannot be turned into an open redirect from the trusted MJAPI origin. Normally wired to
@@ -54,7 +54,7 @@ export interface OAuthCallbackHandlerOptions {
      * dependency on configuration loading — importing the config module validates the whole config
      * as a side effect, which makes this handler unimportable in any context without one.
      */
-    allowedFrontendOrigins: string[];
+    allowedFrontendOrigins: string[];  // case-violation-ok-legacy-back-compat: renaming it broke a use the checker could not see from the declaration — the compile proved it
 }
 
 /**
@@ -863,16 +863,26 @@ export class OAuthCallbackHandler {
     /**
      * Gets the router for unauthenticated callback endpoint.
      */
-    public getCallbackRouter(): express.Router {
+    public GetCallbackRouter(): express.Router {
         return this.callbackRouter;
     }
 
+    /** @deprecated Use {@link GetCallbackRouter}. */
+    public getCallbackRouter(): express.Router {
+        return this.GetCallbackRouter();
+    }
+
     /**
      * Gets the router for authenticated OAuth endpoints.
      */
-    public getAuthenticatedRouter(): express.Router {
+    public GetAuthenticatedRouter(): express.Router {
         return this.authenticatedRouter;
     }
+
+    /** @deprecated Use {@link GetAuthenticatedRouter}. */
+    public getAuthenticatedRouter(): express.Router {
+        return this.GetAuthenticatedRouter();
+    }
 }
 
 /**
@@ -881,7 +891,7 @@ export class OAuthCallbackHandler {
  * @param options - Handler configuration
  * @returns Object with callback and authenticated routers
  */
-export function createOAuthCallbackHandler(options: OAuthCallbackHandlerOptions): {
+export function CreateOAuthCallbackHandler(options: OAuthCallbackHandlerOptions): {
     callbackRouter: express.Router;
     authenticatedRouter: express.Router;
 } {
@@ -891,3 +901,11 @@ export function createOAuthCallbackHandler(options: OAuthCallbackHandlerOptions)
         authenticatedRouter: handler.getAuthenticatedRouter()
     };
 }
+
+/** @deprecated Use {@link CreateOAuthCallbackHandler}. */
+export function createOAuthCallbackHandler(options: OAuthCallbackHandlerOptions): {
+    callbackRouter: express.Router;
+    authenticatedRouter: express.Router;
+} {
+    return CreateOAuthCallbackHandler(options);
+}

package/src/rest/RESTEndpointHandler.ts

@@ -16,7 +16,7 @@ export interface RESTEndpointHandlerOptions {
      * If provided, only these entities will be accessible through the REST API
      * Supports wildcards using '*' (e.g., 'User*' matches 'User', 'UserRole', etc.)
      */
-    includeEntities?: string[];
+    IncludeEntities?: string[];
     
     /**
      * Array of entity names to exclude from the API (case-insensitive)
@@ -24,20 +24,20 @@ export interface RESTEndpointHandlerOptions {
      * Supports wildcards using '*' (e.g., 'Secret*' matches 'Secret', 'SecretKey', etc.)
      * Note: Exclude patterns always override include patterns
      */
-    excludeEntities?: string[];
+    ExcludeEntities?: string[];
     
     /**
      * Array of schema names to include in the API (case-insensitive)
      * If provided, only entities in these schemas will be accessible through the REST API
      */
-    includeSchemas?: string[];
+    IncludeSchemas?: string[];
     
     /**
      * Array of schema names to exclude from the API (case-insensitive)
      * Entities in these schemas will not be accessible through the REST API
      * Note: Exclude patterns always override include patterns
      */
-    excludeSchemas?: string[];
+    ExcludeSchemas?: string[];
 }
 
 /**
@@ -85,21 +85,21 @@ export class RESTEndpointHandler {
         const schemaName = entity.SchemaName.toLowerCase();
         
         // 1. Check schema exclusions first (these take highest precedence)
-        if (this.options.excludeSchemas && this.options.excludeSchemas.length > 0) {
-            if (this.options.excludeSchemas.some(schema => schema.toLowerCase() === schemaName)) {
+        if (this.options.ExcludeSchemas && this.options.ExcludeSchemas.length > 0) {
+            if (this.options.ExcludeSchemas.some(schema => schema.toLowerCase() === schemaName)) {
                 return false;
             }
         }
         
         // 2. Check entity exclusions next (these override entity inclusions)
-        if (this.options.excludeEntities && this.options.excludeEntities.length > 0) {
+        if (this.options.ExcludeEntities && this.options.ExcludeEntities.length > 0) {
             // Check for direct match
-            if (this.options.excludeEntities.includes(name)) {
+            if (this.options.ExcludeEntities.includes(name)) {
                 return false;
             }
             
             // Check for wildcard matches
-            for (const pattern of this.options.excludeEntities) {
+            for (const pattern of this.options.ExcludeEntities) {
                 if (pattern.includes('*')) {
                     const regex = new RegExp('^' + pattern.toLowerCase().replace(/\*/g, '.*') + '$');
                     if (regex.test(name)) {
@@ -110,21 +110,21 @@ export class RESTEndpointHandler {
         }
         
         // 3. Check schema inclusions (if specified, only entities from these schemas are allowed)
-        if (this.options.includeSchemas && this.options.includeSchemas.length > 0) {
-            if (!this.options.includeSchemas.some(schema => schema.toLowerCase() === schemaName)) {
+        if (this.options.IncludeSchemas && this.options.IncludeSchemas.length > 0) {
+            if (!this.options.IncludeSchemas.some(schema => schema.toLowerCase() === schemaName)) {
                 return false;
             }
         }
         
         // 4. Check entity inclusions
-        if (this.options.includeEntities && this.options.includeEntities.length > 0) {
+        if (this.options.IncludeEntities && this.options.IncludeEntities.length > 0) {
             // Check for direct match
-            if (this.options.includeEntities.includes(name)) {
+            if (this.options.IncludeEntities.includes(name)) {
                 return true;
             }
             
             // Check for wildcard matches
-            for (const pattern of this.options.includeEntities) {
+            for (const pattern of this.options.IncludeEntities) {
                 if (pattern.includes('*')) {
                     const regex = new RegExp('^' + pattern.toLowerCase().replace(/\*/g, '.*') + '$');
                     if (regex.test(name)) {
@@ -804,7 +804,12 @@ export class RESTEndpointHandler {
     /**
      * Get the Express router with all configured routes
      */
-    public getRouter(): express.Router {
+    public GetRouter(): express.Router {
         return this.router;
     }
+
+    /** @deprecated Use {@link GetRouter}. */
+    public getRouter(): express.Router {
+        return this.GetRouter();
+    }
 }

package/src/rest/RealtimeSdpBrokerHandler.ts

@@ -8,7 +8,7 @@ import { LogError, LogStatus } from '@memberjunction/core';
  * BEFORE any request body parsing occurs. This prevents anonymous/unauthorized callers
  * from causing body-parser memory allocations.
  */
-export function requireTicket(req: Request, res: Response, next: NextFunction): void {
+export function RequireTicket(req: Request, res: Response, next: NextFunction): void {
     const ticketId = (req.query['ticket'] as string) || '';
     if (!ticketId) {
         res.status(401).json({ error: 'Unauthorized: missing ticket' });
@@ -26,6 +26,11 @@ export function requireTicket(req: Request, res: Response, next: NextFunction):
     next();
 }
 
+/** @deprecated Use {@link RequireTicket}. */
+export function requireTicket(req: Request, res: Response, next: NextFunction): void {
+    return RequireTicket(req, res, next);
+}
+
 /**
  * Builds the Express router handling the Realtime WebRTC SDP exchange:
  * `POST /realtime/sdp-exchange?ticket=<ticketId>`
@@ -36,12 +41,12 @@ export function requireTicket(req: Request, res: Response, next: NextFunction):
  * BEFORE body parsing, delegates to `driver.ExchangeWebRtcSdp` to exchange the SDP offer for an
  * answer with upstream using the server's API key, and returns the answer SDP.
  */
-export function createRealtimeSdpBrokerRouter(): Router {
+export function CreateRealtimeSdpBrokerRouter(): Router {
     const router = express.Router();
 
     router.post(
         '/',
-        requireTicket,
+        RequireTicket,
         express.json({ limit: '2mb' }),
         async (req: Request, res: Response): Promise<void> => {
             const entry = res.locals.ticketEntry as RealtimeProxyTicketEntry;
@@ -95,7 +100,12 @@ export function createRealtimeSdpBrokerRouter(): Router {
     return router;
 }
 
+/** @deprecated Use {@link CreateRealtimeSdpBrokerRouter}. */
+export function createRealtimeSdpBrokerRouter(): Router {
+    return CreateRealtimeSdpBrokerRouter();
+}
+
 /**
  * @deprecated Use `createRealtimeSdpBrokerRouter` instead.
  */
-export const createOpenAILiveBrokerRouter = createRealtimeSdpBrokerRouter;
+export const createOpenAILiveBrokerRouter = CreateRealtimeSdpBrokerRouter;