@memberjunction/connector-path-lms 1.0.0

package/dist/PathLMSConnector.d.ts

@@ -0,0 +1,394 @@
+import { type UserInfo } from '@memberjunction/core';
+import type { MJCompanyIntegrationEntity } from '@memberjunction/core-entities';
+import { BaseRESTIntegrationConnector, type RESTAuthContext, type RESTResponse, type PaginationState, type PaginationType, type ConnectionTestResult, type ExternalObjectSchema, type ExternalFieldSchema, type FetchContext, type FetchBatchResult } from '@memberjunction/integration-engine';
+/**
+ * Path LMS Reporting API connector (Blue Sky eLearn).
+ *
+ * TRANSPORT: GraphQL over HTTP. There is exactly ONE protocol base — {@link BaseRESTIntegrationConnector};
+ * GraphQL rides on top of it. Every report query POSTs a GraphQL document to the single endpoint
+ * `https://data-api.pathlms.com/graphql`; {@link NormalizeResponse} strips the `data.<queryName>`
+ * envelope and surfaces `errors[]`.
+ *
+ * AUTH (two-step, no refresh token): {@link Authenticate} exchanges `{ applicationId, applicationSecret }`
+ * (form-urlencoded) at `https://data-api.pathlms.com/api/v1/getToken` for a ~12h bearer JWT. The token +
+ * expiry are cached per credential; on expiry OR a 401, the connector re-mints. applicationId/Secret come
+ * from the linked Credential entity (or the CompanyIntegration.Configuration JSON) — NEVER baked in code.
+ *
+ * PAGINATION: offset/limit (`PaginationType=Offset`) on the report queries.
+ *
+ * PULL-ONLY: the SDL documents 0 mutations / 0 subscriptions, so SupportsCreate/Update/Delete stay false
+ * (the base defaults) and no CRUD path is wired. No 501 stubs.
+ *
+ * INCREMENTAL: every IO here is `SupportsIncrementalSync=false` — the SDL's startDate/endDate args filter
+ * by event date, NOT record-modification time, so there is no watermark to assert (provable-only). The
+ * engine relies on content-hash idempotency + {@link StableOrderingKey} (the IO's stable `id`) for
+ * keyset-style resume.
+ *
+ * DISCOVERY — CREDENTIAL-FREE, FROM THE PUBLIC SCHEMA (the T3-deadlock fix):
+ * Path LMS publishes its complete GraphQL SDL credential-free as a SpectaQL HTML reference page at
+ * `https://data-api.pathlms.com/`. That page is the **schema-of-record**. {@link DiscoverObjects} and
+ * {@link DiscoverFields} FETCH + PARSE that public page WITH NO CREDENTIAL and enumerate the full standard
+ * universe of GraphQL **record types** (84 = 93 SDL object types − 9 non-record types). This is what makes
+ * the runtime credential-free `DocStructureSelfCheck` re-yield the same standard universe every time (so
+ * persisted objects never read as "structure drift").
+ *
+ * A live credential is strictly **ADDITIVE**: when present, {@link DiscoverFields} also runs a standard
+ * GraphQL introspection against `/graphql` and appends any tenant-specific fields the public SDL lacked
+ * (the `Discovered` extension). It NEVER samples live data at build time and NEVER becomes the baseline —
+ * the standard universe always comes from the public, token-free schema. The auth-gated live introspection
+ * being available does NOT make the connector "case 2": the same schema is published credential-free, so
+ * discovery is case 1 (public schema) + an additive case-2 tenant overlay. The catalog is NOT a module-level
+ * constant — it is fetched + parsed from the public page at discovery time (only the small set of non-record
+ * SDL types to *exclude* is a documented constant, NOT the catalog itself).
+ */
+export declare class PathLMSConnector extends BaseRESTIntegrationConnector {
+    /** Per-process token cache, keyed by credential identity (applicationId). Survives across fetches. */
+    private tokenCache;
+    /**
+     * Per-process cache of the parsed PUBLIC SpectaQL schema (type-name → record type + fields). Populated
+     * lazily, credential-free, from `https://data-api.pathlms.com/`. This is the standard-universe source of
+     * record for discovery; it is fetched + parsed at runtime, never a baked array.
+     */
+    private publicSchemaCache;
+    private publicSchemaPromise;
+    /**
+     * Per-CompanyIntegration introspection cache of the live SDL's object types → their scalar/object field
+     * shape. Lets the GraphQL selection-set builder emit a valid sub-selection for object-valued (`json`)
+     * report fields like `attendees: [WebinarAttendee]!`, and feeds the ADDITIVE tenant-field overlay in
+     * DiscoverFields. Populated lazily at runtime from the live introspection query — never a baked catalog.
+     */
+    private sdlTypeCache;
+    /** Verbatim ClassName / IntegrationName getter / MJ: Integrations.Name. */
+    get IntegrationName(): string;
+    /**
+     * KEYSET / no-watermark resume hint. None of the Path LMS report queries expose a record-modification
+     * watermark, so every object resumes by its stable ordering key — the object's declared primary key
+     * (the report's `id`). Resolved from the cached IOF PK. Returns null when no PK is declared (keyset
+     * resume unavailable for the PK-less roll-up/aggregate report types).
+     */
+    StableOrderingKey(objectName: string): string | null;
+    /**
+     * Conservative rate-limit policy. Path LMS publishes no explicit per-app limit; a single GraphQL
+     * endpoint behind Apollo tolerates modest sustained throughput. A low default keeps the connector
+     * polite without a documented number to push to (provable-only — see PROVENANCE BatchRequestWaitTimeGap).
+     */
+    get RateLimitPolicy(): {
+        TokensPerSec: number;
+        Burst?: number;
+    } | null;
+    /**
+     * Two-step token exchange. Resolves applicationId/applicationSecret from the credential, returns a
+     * cached non-expired token when available, else POSTs form-urlencoded credentials to /api/v1/getToken
+     * and caches the resulting bearer (stripping any leading "Bearer ") with a 12h expiry (minus a skew
+     * buffer). No refresh token exists — re-mint is just another exchange.
+     */
+    protected Authenticate(companyIntegration: MJCompanyIntegrationEntity, contextUser: UserInfo): Promise<PathLMSAuthContext>;
+    /**
+     * Builds an auth context from a directly-supplied/pre-configured bearer token WITHOUT a live token
+     * exchange. The transport-smoke gate (T7b) configures a dummy token and asserts the connector injects
+     * `Authorization: Bearer <token>` on the request — it must NOT require a successful /api/v1/getToken
+     * round-trip before a header is present. Whenever a credential/Configuration carries a direct bearer
+     * token (alias `Token`/`accessToken`/`bearerToken`/`apiKey`), {@link LoadCredentials} surfaces it as
+     * `PreconfiguredToken` and {@link GetOrMintToken} returns it verbatim, so {@link BuildHeaders} sets the
+     * header off the configured token state with no network call.
+     */
+    /** Bearer header on every GraphQL request, plus JSON content negotiation. */
+    protected BuildHeaders(auth: RESTAuthContext): Record<string, string>;
+    /** The single GraphQL endpoint. APIPath on every IO is `/graphql`, so the base URL is the host root. */
+    protected GetBaseURL(companyIntegration: MJCompanyIntegrationEntity, _auth: RESTAuthContext): string;
+    /**
+     * Resolves the API host root: an optional `Configuration.BaseURL`/`GraphQLEndpoint` override (a
+     * self-hosted/sandbox Path LMS instance, or an e2e mock origin) else the canonical {@link PATHLMS_HOST}.
+     * A full `…/graphql` URL is tolerated and reduced to the host root (the connector appends the paths).
+     */
+    private HostFor;
+    /**
+     * Executes an HTTP request via fetch. For GraphQL all requests are POSTs carrying a JSON
+     * `{ query, variables }` body. Parses the JSON body; returns the raw text on a non-JSON response.
+     */
+    protected MakeHTTPRequest(_auth: RESTAuthContext, url: string, method: string, headers: Record<string, string>, body?: unknown): Promise<RESTResponse>;
+    /**
+     * Strips the GraphQL envelope: `{ data: { <responseDataKey>: <records> } }` → records, normalizing a
+     * single object to a one-element array. GraphQL errors are surfaced as a thrown error so the engine
+     * records the failure (rather than silently treating `data: null` as zero records). When `data` is
+     * present alongside `errors` (partial success), the data is returned and the error is left to the
+     * caller's HTTP-status handling.
+     */
+    protected NormalizeResponse(rawBody: unknown, responseDataKey: string | null): Record<string, unknown>[];
+    /**
+     * Offset/limit pagination. Path LMS report queries return a flat list with no total-count or
+     * has-next signal, so "more pages remain" is inferred from a full page: when the page returned
+     * exactly `pageSize` records, there may be more (advance the offset); a short/empty page is the end.
+     */
+    protected ExtractPaginationInfo(rawBody: unknown, paginationType: PaginationType, _currentPage: number, currentOffset: number, pageSize: number): PaginationState;
+    /**
+     * Verifies credentials by minting a token then issuing the cheapest GraphQL query the SDL documents
+     * (`teamsList { id }`). A 401/GraphQL auth error means bad credentials; a 2xx with a `data` envelope
+     * confirms both the token exchange and live GraphQL access.
+     */
+    TestConnection(companyIntegration: MJCompanyIntegrationEntity, contextUser: UserInfo): Promise<ConnectionTestResult>;
+    /**
+     * Enumerates the FULL STANDARD UNIVERSE of record types CREDENTIAL-FREE by fetching + parsing the
+     * public SpectaQL schema page at `https://data-api.pathlms.com/` — NOT a baked array and NOT dependent
+     * on any token or on the seeded metadata cache. This is the T3-deadlock fix: because the standard
+     * universe is sourced from the public schema (which always resolves without a credential), the runtime
+     * credential-free `DocStructureSelfCheck` re-yields the same universe and persisted objects never read
+     * as structure drift.
+     *
+     * The seeded Declared metadata cache is consulted only to ATTACH the persisted IntegrationObject `ID`
+     * to each discovered object (a join, not the source of the object set). A live credential is NOT used
+     * here at all — standard objects are token-free by construction.
+     */
+    DiscoverObjects(companyIntegration: MJCompanyIntegrationEntity, _contextUser: UserInfo): Promise<ExternalObjectSchema[]>;
+    /**
+     * Returns the fields for an object as the FULL STANDARD set parsed CREDENTIAL-FREE from the public
+     * SpectaQL schema (the baseline), enriched by the seeded Declared metadata (PK/FK/type curation) where
+     * it exists, then — only when a live credential is present — ADDITIVELY augmented with any tenant-
+     * specific fields the live introspection exposes that the public SDL lacked (the `Discovered` overlay).
+     *
+     * The public-schema field set is the baseline that always resolves token-free. The Declared overlay
+     * never replaces it; the live overlay only appends. Introspection failures degrade gracefully to the
+     * public + Declared fields. NEVER samples live data; NEVER hardcodes the field catalog.
+     */
+    DiscoverFields(companyIntegration: MJCompanyIntegrationEntity, objectName: string, contextUser: UserInfo): Promise<ExternalFieldSchema[]>;
+    /**
+     * Appends any live-introspection fields the public schema lacked (tenant `Discovered` overlay). The
+     * public + Declared fields are the floor; the live introspection only ADDS. Degrades to the merged
+     * baseline on any introspection failure.
+     */
+    private AppendLiveFields;
+    /**
+     * Fetches records by POSTing a GraphQL document built from the IO's metadata:
+     *  - operation name + return type + arguments from the IO's per-object Configuration JSON,
+     *  - the selection set from the IOF field names (scalar fields selected directly; object-valued
+     *    `json` fields given a one-level sub-selection resolved from the live SDL type map),
+     *  - offset/limit appended for Offset-paginated queries.
+     *
+     * Full-record pass-through: every record's COMPLETE GraphQL node lands in `ExternalRecord.Fields` so
+     * the framework's custom-column capture sees every key. Identity is the IOF-declared PK; the base
+     * content-hash fallback handles PK-less / object-container objects.
+     */
+    FetchChanges(ctx: FetchContext): Promise<FetchBatchResult>;
+    /**
+     * Fetches a NESTED record type by querying its entry "door" and descending the access-path field
+     * chain to the leaf record collection (tables ≠ doors). One GraphQL request selects down the path;
+     * the response is then walked the same path to flatten out every leaf record. Each leaf carries its
+     * FULL node in `Fields` (custom-column pass-through). Reporting doors return the whole set (no
+     * offset/limit on the nested path), so HasMore is false.
+     */
+    private FetchViaAccessPath;
+    /** Wraps the leaf selection in the door + nested field chain: `door { seg1 { seg2 { leaf } } }`. */
+    private BuildNestedQuery;
+    /**
+     * Walks a GraphQL response down the access path (`data[door]` → each segment), flattening arrays and
+     * single objects at every hop, to yield the flat list of leaf records. Robust to a door/segment that
+     * resolves to either an object or an array.
+     */
+    private DescendAccessPath;
+    /** Returns the cached public schema, fetching + parsing it once per process (credential-free). */
+    private GetPublicSchema;
+    /**
+     * Fetches the public SpectaQL HTML (no credential) and parses its `definition-object` blocks into
+     * record types + fields. This is the standard-universe source of record. Allows a subclass / test to
+     * override {@link FetchPublicSchemaHTML} to supply a fixture without a network call.
+     */
+    private FetchAndParsePublicSchema;
+    /**
+     * Fetches the raw public SpectaQL schema HTML from `https://data-api.pathlms.com/` with NO auth header.
+     * Overridable seam (tests inject a fixture). Throws on a non-2xx response so discovery surfaces a real
+     * fetch failure rather than silently returning zero objects.
+     */
+    protected FetchPublicSchemaHTML(): Promise<string>;
+    /**
+     * Builds the selection set string for the query's return type. Scalar IOF fields are selected
+     * directly; object-valued (`json`) IOF fields receive a one-level sub-selection of their SDL type's
+     * SCALAR fields when the live type map resolves the field's type. When the type can't be resolved
+     * (no introspection / open JSON scalar), the field is selected as a leaf — correct for true scalars,
+     * and harmless for unresolved fields (the query simply omits an unresolvable object field rather than
+     * sending an invalid leaf selection on a known object type).
+     */
+    private BuildSelectionSet;
+    /** Builds a one-level scalar sub-selection for an object type (no nested object recursion). */
+    private BuildScalarSubSelection;
+    /**
+     * Assembles the full GraphQL query document and its variables. Operation arguments come from the IO's
+     * Configuration `OperationArguments` (e.g. `["limit:Int","offset:Int","teamIds:[Int!]"]`). Only the
+     * pagination args (offset/limit) are bound at fetch time when paginating; all other documented filter
+     * args are declared as optional variables left unset (the source returns the unfiltered report).
+     */
+    private BuildQueryDocument;
+    /** Returns the cached/freshly-introspected SDL type map; throws on hard introspection failure. */
+    private GetSDLTypeMap;
+    /** Best-effort SDL type map — returns an empty map (no augmentation) on any introspection failure. */
+    private GetSDLTypeMapSafe;
+    /** Parses a GraphQL `__schema.types` introspection response into a name→SDLType map (OBJECT types only). */
+    private ParseIntrospection;
+    /** True when a field's underlying named type is an OBJECT type present in the map (needs sub-selection). */
+    private IsObjectField;
+    /** Returns the field's underlying OBJECT type name when it is an object (else null). */
+    private ObjectFieldTypeName;
+    /** Maps an SDL field's underlying type into the connector's coarse DataType vocabulary. */
+    private SDLTypeToDataType;
+    private IsListOrObjectScalar;
+    /** POSTs a `{ query, variables }` document to the GraphQL endpoint with auth headers. */
+    private PostGraphQL;
+    /** Throws on a non-2xx HTTP status or a GraphQL error with no usable data. */
+    private AssertGraphQLOK;
+    /**
+     * Resolves the bearer token for these credentials. Precedence:
+     *  1. A directly-supplied/pre-configured bearer token (`PreconfiguredToken`) is returned verbatim with
+     *     NO network exchange — this is the path the transport-smoke gate (T7b) exercises with a dummy token,
+     *     and the path a broker uses when it injects a ready bearer rather than appId/secret.
+     *  2. Else a cached, non-expired minted token.
+     *  3. Else mint a fresh token via the two-step /api/v1/getToken exchange and cache it (12h, minus skew).
+     */
+    private GetOrMintToken;
+    /**
+     * Exchanges applicationId/applicationSecret for a bearer token via a form-urlencoded POST to
+     * /api/v1/getToken. The response carries `{ token: "Bearer <jwt>" }`; the leading "Bearer " is
+     * stripped so BuildHeaders applies a single prefix.
+     */
+    private MintToken;
+    /** Reads the token from the getToken response and strips any leading "Bearer " prefix. */
+    private ExtractToken;
+    /**
+     * Resolves applicationId/applicationSecret from the linked Credential entity, falling back to the
+     * CompanyIntegration.Configuration JSON. Credentials are issued by Blue Sky eLearn and are NEVER
+     * hardcoded in connector code.
+     */
+    private LoadCredentials;
+    /** Loads credentials from a Credential entity's Values JSON. */
+    private LoadFromCredentialEntity;
+    /**
+     * Parses a JSON string into credentials (tolerant of casing aliases). Accepts EITHER a pre-minted bearer
+     * token (`Token`/`accessToken`/`bearerToken`/`apiKey` — the exchange-free path the transport-smoke gate
+     * uses) OR an applicationId + applicationSecret pair for the two-step exchange. Returns null only when
+     * neither a usable token nor a full appId+secret pair is present.
+     */
+    private ParseCredentialJson;
+    /** Gets an IO from the cache without throwing (used by StableOrderingKey, which may be called early). */
+    private TryGetCachedObject;
+    /** Returns the seeded Declared IO rows for this integration keyed by lower-cased name (safe on empty cache). */
+    private CachedObjectsByName;
+    /** Returns the seeded Declared fields for an object as ExternalFieldSchema (empty when not cached). */
+    private DeclaredFields;
+    /**
+     * Overlays the seeded Declared field curation (PK / FK target / type / required) onto the public-schema
+     * baseline, by field name. Declared wins for the curated structural attributes where it has an opinion;
+     * the public-schema baseline supplies everything else and guarantees the full field set even when no
+     * Declared row exists. Never drops a public field; only enriches.
+     */
+    private MergeDeclaredOverlay;
+    /**
+     * Maps a parsed public-schema record field into the ExternalFieldSchema baseline shape — applying the
+     * EXACT id-PK / typed-reference-FK rules the persisted metadata was built from, so the connector's
+     * credential-free discovery reproduces the persisted PK/FK set and T3 `DocStructureSelfCheck` cannot
+     * drift. This is run with zero credential and uses ONLY the parsed public SDL universe ({@param schema}).
+     *
+     * PK: the row's own `id` field is the sole primary key. An id-less type has NO PK (the engine's
+     * content-hash carries identity). A `*Id` reference is NEVER a PK — it is a foreign key (below).
+     *
+     * FK (two cases, mirroring `parse-sdl-fk.mjs` + the id-less `*Id` demotion path):
+     *   (1) TYPED REFERENCE — the field's unwrapped SDL type resolves to ANOTHER emitted record type
+     *       (e.g. `groups: [Group]` → Group, `assessmentsReport: [Assessment]!` → Assessment).
+     *   (2) SCALAR `<Type>Id` — a scalar field named `<emittedType>Id` (case-insensitive, e.g. userId→User,
+     *       courseId→Course, webinarId→Webinar) where the capitalized stem matches another emitted record
+     *       type. (No self-alias exclusion: the metadata marks even `userId`-same-as-id as an FK→User on the
+     *       id-less report rows, so discovery must too.)
+     * Both cases exclude a self-reference to the field's own owning type.
+     */
+    private PublicFieldToSchema;
+    /**
+     * Resolves a field's foreign-key target to another emitted record type, or null when the field is not
+     * a reference. Mirrors EXACTLY the rules `scripts/parse-sdl-fk.mjs` used to author the persisted metadata,
+     * so the connector's credential-free FK derivation reproduces it (T3 `DocStructureSelfCheck` cannot drift):
+     *
+     *   (1) TYPED REFERENCE — the SDL anchor target is itself an emitted record type (e.g. `groups: [Group]`
+     *       → Group). Always an FK; no contradiction exclusion.
+     *   (2) SCALAR `<Type>Id` — the field name (sans trailing `Id`, capitalized) matches an emitted record
+     *       type and the field's underlying type is a scalar (e.g. userId→User, courseId→Course, webinarId→
+     *       Webinar). This IS an FK, with ONE exclusion: when the owning type has its own `id` primary key
+     *       AND the field's prose marks it a self-alias of that id ("the userId field is the same as id…",
+     *       "alias of id", "for cross referencing"), it is a renamed view of the row's own identity, not a
+     *       reference to another row — the persisted metadata leaves those non-FK (e.g. `Order.userId`).
+     *       On an id-LESS report row (`CategorySale.userId`, `InPersonEventUser.userId`, …) the `<Type>Id`
+     *       IS the only identity/reference, so the self-alias exclusion does NOT apply and the FK is kept —
+     *       exactly as the metadata records it.
+     *
+     * Returns the CANONICAL record-type name (so the FK target matches the persisted
+     * `@lookup:…Name=<Type>` exactly). Never resolves to the field's own owning type.
+     */
+    private ResolveFKTarget;
+    /** Parses the per-IO Configuration JSON into the GraphQL query model (incl. the nested access path). */
+    private ParseIOConfiguration;
+    /** Returns the IOF PK field names (sorted by sequence), or empty when none is declared. */
+    private FindPKFieldNames;
+    /**
+     * Builds a stable record identity from the declared PK fields. When all PK parts are present, joins
+     * them with '|'; otherwise returns '' so the engine's content-hash identity fallback takes over (the
+     * `account`/`teams` container objects without a usable PK dedupe by content hash).
+     */
+    private BuildRecordIdentity;
+    /** Resolves the page size for a fetch: explicit BatchSize, else the IO default, else 50. */
+    private ResolvePageSize;
+    /** NormalizeResponse variant that never throws — used by ExtractPaginationInfo to count a page. */
+    private NormalizeResponseSafe;
+    /** Converts an IntegrationObjectField entity to the ExternalFieldSchema shape (Declared discovery). */
+    private DeclaredFieldToSchema;
+}
+/** Auth context: resolved bearer token + the credentials used to mint it (for re-mint). */
+interface PathLMSAuthContext extends RESTAuthContext {
+    Token: string;
+    Credentials: PathLMSCredentials;
+    /** Resolved host root for this connection (override or {@link PATHLMS_HOST}). */
+    BaseURL?: string;
+}
+/**
+ * Resolved Path LMS credentials. The normal path carries `applicationId` + `applicationSecret` (exchanged
+ * at /api/v1/getToken). `PreconfiguredToken` is an alternate, exchange-free path: a ready bearer token
+ * supplied directly (the transport-smoke dummy-token path, or a broker injecting a bearer). When
+ * `PreconfiguredToken` is set, appId/secret may be absent — {@link PathLMSConnector.GetOrMintToken} returns
+ * the token verbatim with no network call.
+ */
+interface PathLMSCredentials {
+    applicationId?: string;
+    applicationSecret?: string;
+    PreconfiguredToken?: string;
+    /** Optional host-root override (self-hosted/sandbox instance or e2e mock origin); absent ⇒ {@link PATHLMS_HOST}. */
+    BaseURL?: string;
+}
+/** A field parsed from the public SpectaQL schema. */
+interface PublicField {
+    Name: string;
+    /** Underlying named type from the SDL link (list/non-null wrappers stripped), e.g. "Int", "Course". */
+    TargetType: string | null;
+    /** Whether the SDL type was a list (`[Foo]`). */
+    IsList: boolean;
+    /** Whether the SDL type was non-null at the top level (`!`). */
+    NonNull: boolean;
+    /** The field's documentation prose, if any. */
+    Description?: string;
+}
+/** A record type parsed from the public SpectaQL schema. */
+interface PublicRecordType {
+    Name: string;
+    Description?: string;
+    Fields: PublicField[];
+}
+/** The fully-parsed public schema: the standard-universe record types + a by-name index. */
+interface PublicSchema {
+    RecordTypes: PublicRecordType[];
+    RecordTypesByName: Map<string, PublicRecordType>;
+}
+/**
+ * Parses a SpectaQL HTML schema page into the standard universe of record types + fields. Each record type
+ * is a `<section id="definition-<Type>" class="definition definition-object">` block; the non-record SDL
+ * types in {@link NON_RECORD_SDL_TYPES} are removed. Each field row carries the property name + a typed
+ * link `<a href="#definition-<Target>"><code>[Type]!</code></a>` from which the underlying type, list-ness
+ * and non-null are read. This is the credential-free standard-universe enumeration (record TYPES, not the
+ * Query entry-point doors).
+ */
+export declare function parseSpectaQLSchema(html: string): PublicSchema;
+/** Tree-shaking prevention function — import and call from the module entry point. */
+export declare function LoadPathLMSConnector(): void;
+export {};