@qlik/api 1.31.0 → 1.33.0

package/assistants.js

@@ -0,0 +1,329 @@
+import {
+  clearApiCache,
+  invokeFetch
+} from "./chunks/LIEZG7IM.js";
+import "./chunks/GPRUNZV4.js";
+import "./chunks/7MMXU6EL.js";
+
+// src/public/rest/assistants.ts
+async function getAssistants(query, options) {
+  return invokeFetch("assistants", {
+    method: "get",
+    pathTemplate: "/api/v1/assistants",
+    query,
+    options
+  });
+}
+async function createAssistant(body, options) {
+  return invokeFetch("assistants", {
+    method: "post",
+    pathTemplate: "/api/v1/assistants",
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function getAssistantFeedback(assistantId, options) {
+  return invokeFetch("assistants", {
+    method: "get",
+    pathTemplate: "/api/v1/assistants/{assistantId}/feedback",
+    pathVariables: { assistantId },
+    options
+  });
+}
+async function getAssistantSources(assistantId, body, options) {
+  return invokeFetch("assistants", {
+    method: "post",
+    pathTemplate: "/api/v1/assistants/{assistantId}/sources/plaintexts",
+    pathVariables: { assistantId },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function getAssistantStarters(assistantId, query, options) {
+  return invokeFetch("assistants", {
+    method: "get",
+    pathTemplate: "/api/v1/assistants/{assistantId}/starters",
+    pathVariables: { assistantId },
+    query,
+    options
+  });
+}
+async function createAssistantStarter(assistantId, body, options) {
+  return invokeFetch("assistants", {
+    method: "post",
+    pathTemplate: "/api/v1/assistants/{assistantId}/starters",
+    pathVariables: { assistantId },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function deleteAssistantStarter(assistantId, starterId, options) {
+  return invokeFetch("assistants", {
+    method: "delete",
+    pathTemplate: "/api/v1/assistants/{assistantId}/starters/{starterId}",
+    pathVariables: { assistantId, starterId },
+    options
+  });
+}
+async function getAssistantStarter(assistantId, starterId, options) {
+  return invokeFetch("assistants", {
+    method: "get",
+    pathTemplate: "/api/v1/assistants/{assistantId}/starters/{starterId}",
+    pathVariables: { assistantId, starterId },
+    options
+  });
+}
+async function updateAssistantStarter(assistantId, starterId, body, options) {
+  return invokeFetch("assistants", {
+    method: "put",
+    pathTemplate: "/api/v1/assistants/{assistantId}/starters/{starterId}",
+    pathVariables: { assistantId, starterId },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function deleteAssistantStarterFollowup(assistantId, starterId, followupId, options) {
+  return invokeFetch("assistants", {
+    method: "delete",
+    pathTemplate: "/api/v1/assistants/{assistantId}/starters/{starterId}/followups/{followupId}",
+    pathVariables: { assistantId, starterId, followupId },
+    options
+  });
+}
+async function updateAssistantStarterFollowup(assistantId, starterId, followupId, body, options) {
+  return invokeFetch("assistants", {
+    method: "put",
+    pathTemplate: "/api/v1/assistants/{assistantId}/starters/{starterId}/followups/{followupId}",
+    pathVariables: { assistantId, starterId, followupId },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function getAssistantThreads(assistantId, query, options) {
+  return invokeFetch("assistants", {
+    method: "get",
+    pathTemplate: "/api/v1/assistants/{assistantId}/threads",
+    pathVariables: { assistantId },
+    query,
+    options
+  });
+}
+async function createAssistantThread(assistantId, body, options) {
+  return invokeFetch("assistants", {
+    method: "post",
+    pathTemplate: "/api/v1/assistants/{assistantId}/threads",
+    pathVariables: { assistantId },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function invokeAssistantThread(assistantId, threadId, body, options) {
+  return invokeFetch("assistants", {
+    method: "post",
+    pathTemplate: "/api/v1/assistants/{assistantId}/threads/{threadId}/actions/invoke",
+    pathVariables: { assistantId, threadId },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function streamAssistantThread(assistantId, threadId, body, options) {
+  return invokeFetch("assistants", {
+    method: "post",
+    pathTemplate: "/api/v1/assistants/{assistantId}/threads/{threadId}/actions/stream",
+    pathVariables: { assistantId, threadId },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function getAssistantThreadInteractions(assistantId, threadId, query, options) {
+  return invokeFetch("assistants", {
+    method: "get",
+    pathTemplate: "/api/v1/assistants/{assistantId}/threads/{threadId}/interactions",
+    pathVariables: { assistantId, threadId },
+    query,
+    options
+  });
+}
+async function createAssistantThreadInteraction(assistantId, threadId, body, options) {
+  return invokeFetch("assistants", {
+    method: "post",
+    pathTemplate: "/api/v1/assistants/{assistantId}/threads/{threadId}/interactions",
+    pathVariables: { assistantId, threadId },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function deleteAssistantThreadInteraction(assistantId, threadId, interactionId, options) {
+  return invokeFetch("assistants", {
+    method: "delete",
+    pathTemplate: "/api/v1/assistants/{assistantId}/threads/{threadId}/interactions/{interactionId}",
+    pathVariables: { assistantId, threadId, interactionId },
+    options
+  });
+}
+async function getAssistantThreadInteraction(assistantId, threadId, interactionId, options) {
+  return invokeFetch("assistants", {
+    method: "get",
+    pathTemplate: "/api/v1/assistants/{assistantId}/threads/{threadId}/interactions/{interactionId}",
+    pathVariables: { assistantId, threadId, interactionId },
+    options
+  });
+}
+async function createAssistantThreadInteractionFeedback(assistantId, threadId, interactionId, body, options) {
+  return invokeFetch("assistants", {
+    method: "post",
+    pathTemplate: "/api/v1/assistants/{assistantId}/threads/{threadId}/interactions/{interactionId}/feedback",
+    pathVariables: { assistantId, threadId, interactionId },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function patchAssistantThreadInteractionFeedback(assistantId, threadId, interactionId, feedbackId, body, options) {
+  return invokeFetch("assistants", {
+    method: "patch",
+    pathTemplate: "/api/v1/assistants/{assistantId}/threads/{threadId}/interactions/{interactionId}/feedback/{feedbackId}",
+    pathVariables: { assistantId, threadId, interactionId, feedbackId },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function createAssistantThreadInteractionReview(assistantId, threadId, interactionId, body, options) {
+  return invokeFetch("assistants", {
+    method: "post",
+    pathTemplate: "/api/v1/assistants/{assistantId}/threads/{threadId}/interactions/{interactionId}/reviews",
+    pathVariables: { assistantId, threadId, interactionId },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function deleteAssistantThread(assistantid, threadid, options) {
+  return invokeFetch("assistants", {
+    method: "delete",
+    pathTemplate: "/api/v1/assistants/{assistantid}/threads/{threadid}",
+    pathVariables: { assistantid, threadid },
+    options
+  });
+}
+async function getAssistantThread(assistantid, threadid, options) {
+  return invokeFetch("assistants", {
+    method: "get",
+    pathTemplate: "/api/v1/assistants/{assistantid}/threads/{threadid}",
+    pathVariables: { assistantid, threadid },
+    options
+  });
+}
+async function patchAssistantThread(assistantid, threadid, body, options) {
+  return invokeFetch("assistants", {
+    method: "patch",
+    pathTemplate: "/api/v1/assistants/{assistantid}/threads/{threadid}",
+    pathVariables: { assistantid, threadid },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function deleteAssistant(id, options) {
+  return invokeFetch("assistants", {
+    method: "delete",
+    pathTemplate: "/api/v1/assistants/{id}",
+    pathVariables: { id },
+    options
+  });
+}
+async function getAssistant(id, options) {
+  return invokeFetch("assistants", {
+    method: "get",
+    pathTemplate: "/api/v1/assistants/{id}",
+    pathVariables: { id },
+    options
+  });
+}
+async function patchAssistant(id, body, options) {
+  return invokeFetch("assistants", {
+    method: "patch",
+    pathTemplate: "/api/v1/assistants/{id}",
+    pathVariables: { id },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+function clearCache() {
+  return clearApiCache("assistants");
+}
+var assistantsExport = {
+  getAssistants,
+  createAssistant,
+  getAssistantFeedback,
+  getAssistantSources,
+  getAssistantStarters,
+  createAssistantStarter,
+  deleteAssistantStarter,
+  getAssistantStarter,
+  updateAssistantStarter,
+  deleteAssistantStarterFollowup,
+  updateAssistantStarterFollowup,
+  getAssistantThreads,
+  createAssistantThread,
+  invokeAssistantThread,
+  streamAssistantThread,
+  getAssistantThreadInteractions,
+  createAssistantThreadInteraction,
+  deleteAssistantThreadInteraction,
+  getAssistantThreadInteraction,
+  createAssistantThreadInteractionFeedback,
+  patchAssistantThreadInteractionFeedback,
+  createAssistantThreadInteractionReview,
+  deleteAssistantThread,
+  getAssistantThread,
+  patchAssistantThread,
+  deleteAssistant,
+  getAssistant,
+  patchAssistant,
+  clearCache
+};
+var assistants_default = assistantsExport;
+export {
+  clearCache,
+  createAssistant,
+  createAssistantStarter,
+  createAssistantThread,
+  createAssistantThreadInteraction,
+  createAssistantThreadInteractionFeedback,
+  createAssistantThreadInteractionReview,
+  assistants_default as default,
+  deleteAssistant,
+  deleteAssistantStarter,
+  deleteAssistantStarterFollowup,
+  deleteAssistantThread,
+  deleteAssistantThreadInteraction,
+  getAssistant,
+  getAssistantFeedback,
+  getAssistantSources,
+  getAssistantStarter,
+  getAssistantStarters,
+  getAssistantThread,
+  getAssistantThreadInteraction,
+  getAssistantThreadInteractions,
+  getAssistantThreads,
+  getAssistants,
+  invokeAssistantThread,
+  patchAssistant,
+  patchAssistantThread,
+  patchAssistantThreadInteractionFeedback,
+  streamAssistantThread,
+  updateAssistantStarter,
+  updateAssistantStarterFollowup
+};

package/audits.d.ts

@@ -1,5 +1,5 @@
-import { A as ApiCallOptions } from './invoke-fetch-types-Cq7bjkqn.js';
-import './auth-types-DqfMuSRX.js';
+import { A as ApiCallOptions } from './invoke-fetch-types-BYCD4pc9.js';
+import './auth-types-Cj5bM3Yk.js';
 
 type ArchiveItem = {
     /** The type that content is encoded in, always "application/json". */
@@ -116,7 +116,7 @@ type Href = {
  * @param query an object with query parameters
  * @throws GetAuditsHttpError
  */
-declare const getAudits: (query: {
+declare function getAudits(query: {
     /** The start/end time interval formatted in ISO 8601 to search by eventTime. For example, "?eventTime=2021-07-14T18:41:15.00Z/2021-07-14T18:41:15.99Z". */
     eventTime?: string;
     /** The case-sensitive string used to search by eventType. Retrieve a list of possible eventTypes with `/v1/audits/types`. */
@@ -135,7 +135,7 @@ declare const getAudits: (query: {
     source?: string;
     /** The case-sensitive string used to search by userId. */
     userId?: string;
-}, options?: ApiCallOptions) => Promise<GetAuditsHttpResponse>;
+}, options?: ApiCallOptions): Promise<GetAuditsHttpResponse>;
 type GetAuditsHttpResponse = {
     data: GetResult;
     headers: Headers;
@@ -154,10 +154,10 @@ type GetAuditsHttpError = {
  * @param query an object with query parameters
  * @throws GetArchivedAuditsHttpError
  */
-declare const getArchivedAudits: (query: {
+declare function getArchivedAudits(query: {
     /** Date to be used as filter and criteria during extraction. */
     date: string;
-}, options?: ApiCallOptions) => Promise<GetArchivedAuditsHttpResponse>;
+}, options?: ApiCallOptions): Promise<GetArchivedAuditsHttpResponse>;
 type GetArchivedAuditsHttpResponse = {
     data: GetArchiveResult;
     headers: Headers;
@@ -173,7 +173,7 @@ type GetArchivedAuditsHttpError = {
  *
  * @throws GetAuditsSettingsHttpError
  */
-declare const getAuditsSettings: (options?: ApiCallOptions) => Promise<GetAuditsSettingsHttpResponse>;
+declare function getAuditsSettings(options?: ApiCallOptions): Promise<GetAuditsSettingsHttpResponse>;
 type GetAuditsSettingsHttpResponse = {
     data: GetSettingsResult;
     headers: Headers;
@@ -189,7 +189,7 @@ type GetAuditsSettingsHttpError = {
  *
  * @throws GetAuditSourcesHttpError
  */
-declare const getAuditSources: (options?: ApiCallOptions) => Promise<GetAuditSourcesHttpResponse>;
+declare function getAuditSources(options?: ApiCallOptions): Promise<GetAuditSourcesHttpResponse>;
 type GetAuditSourcesHttpResponse = {
     data: GetObjectsResult;
     headers: Headers;
@@ -207,7 +207,7 @@ type GetAuditSourcesHttpError = {
  *
  * @throws GetAuditTypesHttpError
  */
-declare const getAuditTypes: (options?: ApiCallOptions) => Promise<GetAuditTypesHttpResponse>;
+declare function getAuditTypes(options?: ApiCallOptions): Promise<GetAuditTypesHttpResponse>;
 type GetAuditTypesHttpResponse = {
     data: GetObjectsResult;
     headers: Headers;
@@ -226,7 +226,7 @@ type GetAuditTypesHttpError = {
  * @param id The audit item's unique identifier.
  * @throws GetAuditHttpError
  */
-declare const getAudit: (id: string, options?: ApiCallOptions) => Promise<GetAuditHttpResponse>;
+declare function getAudit(id: string, options?: ApiCallOptions): Promise<GetAuditHttpResponse>;
 type GetAuditHttpResponse = {
     data: GetByIDResult;
     headers: Headers;

package/audits.js

@@ -1,44 +1,56 @@
 import {
   clearApiCache,
   invokeFetch
-} from "./chunks/YKZ2QYHN.js";
-import "./chunks/DLKLPD7T.js";
-import "./chunks/2ZQ3ZX7F.js";
+} from "./chunks/LIEZG7IM.js";
+import "./chunks/GPRUNZV4.js";
+import "./chunks/7MMXU6EL.js";
 
 // src/public/rest/audits.ts
-var getAudits = async (query, options) => invokeFetch("audits", {
-  method: "get",
-  pathTemplate: "/api/v1/audits",
-  query,
-  options
-});
-var getArchivedAudits = async (query, options) => invokeFetch("audits", {
-  method: "get",
-  pathTemplate: "/api/v1/audits/archive",
-  query,
-  options
-});
-var getAuditsSettings = async (options) => invokeFetch("audits", {
-  method: "get",
-  pathTemplate: "/api/v1/audits/settings",
-  options
-});
-var getAuditSources = async (options) => invokeFetch("audits", {
-  method: "get",
-  pathTemplate: "/api/v1/audits/sources",
-  options
-});
-var getAuditTypes = async (options) => invokeFetch("audits", {
-  method: "get",
-  pathTemplate: "/api/v1/audits/types",
-  options
-});
-var getAudit = async (id, options) => invokeFetch("audits", {
-  method: "get",
-  pathTemplate: "/api/v1/audits/{id}",
-  pathVariables: { id },
-  options
-});
+async function getAudits(query, options) {
+  return invokeFetch("audits", {
+    method: "get",
+    pathTemplate: "/api/v1/audits",
+    query,
+    options
+  });
+}
+async function getArchivedAudits(query, options) {
+  return invokeFetch("audits", {
+    method: "get",
+    pathTemplate: "/api/v1/audits/archive",
+    query,
+    options
+  });
+}
+async function getAuditsSettings(options) {
+  return invokeFetch("audits", {
+    method: "get",
+    pathTemplate: "/api/v1/audits/settings",
+    options
+  });
+}
+async function getAuditSources(options) {
+  return invokeFetch("audits", {
+    method: "get",
+    pathTemplate: "/api/v1/audits/sources",
+    options
+  });
+}
+async function getAuditTypes(options) {
+  return invokeFetch("audits", {
+    method: "get",
+    pathTemplate: "/api/v1/audits/types",
+    options
+  });
+}
+async function getAudit(id, options) {
+  return invokeFetch("audits", {
+    method: "get",
+    pathTemplate: "/api/v1/audits/{id}",
+    pathVariables: { id },
+    options
+  });
+}
 function clearCache() {
   return clearApiCache("audits");
 }

package/{auth-types-DqfMuSRX.d.ts → auth-types-Cj5bM3Yk.d.ts}

@@ -58,8 +58,20 @@ type AuthenticationErrorAction = {
      */
     preventDefault?: boolean;
 };
+/** A typed string array with extracted required properties from a type */
+type RequiredKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+}[keyof T];
+/** A typed string array with extracted optional properties from a type */
+type OptionalKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? K : never;
+}[keyof T];
 /** An authentication module for a specific authentication format, like oauth, cookies etc */
 type AuthModule<A extends AuthType = AuthType> = {
+    /** Properties required for this auth module */
+    requiredProps?: RequiredKeys<HostConfig<A>>[];
+    /** Properties that are optional for this auth module */
+    optionalProps?: OptionalKeys<HostConfig<A>>[];
     /** Get auth params for rest api calls */
     getRestCallAuthParams: (props: GetRestCallAuthParamsProps<A>) => Promise<RestCallAuthParams>;
     /** Get auth params for websocket api calls */
@@ -77,14 +89,6 @@ type AuthType = keyof QlikAuthModules;
 type HostConfig<A extends AuthType = AuthType> = {
     [K in keyof QlikAuthModules]: QlikAuthModuleConfigUnion<K> & HostConfigCommon;
 }[A];
-/** The keys in this interface are used to determine what auth types that are allowed to be set to undefined */
-interface ImplicitQlikAuthModules {
-    apikey: object;
-    oauth2: object;
-    cookie: object;
-    reference: object;
-    anonymous: object;
-}
 type QlikAuthModuleConfigUnion<K extends keyof QlikAuthModules> = (K extends keyof ImplicitQlikAuthModules ? {
     authType?: K;
 } : {
@@ -103,5 +107,21 @@ type HostConfigCommon = {
         message: string;
     }) => unknown;
 };
+/**
+ * These properties are always allowed in the host config, even if they are not defined in the HostConfig interface
+ * for the specific auth module.
+ */
+declare const hostConfigCommonProperties: (keyof HostConfig)[];
+/** The keys in this interface are used to determine what auth types that are allowed to be set to undefined */
+interface ImplicitQlikAuthModules {
+    apikey: object;
+    oauth2: object;
+    cookie: object;
+    windowscookie: object;
+    reference: object;
+    anonymous: object;
+}
+type AuthTypeThatCanBeOmitted = keyof ImplicitQlikAuthModules;
+declare const authTypesThatCanBeOmitted: AuthTypeThatCanBeOmitted[];
 
-export type { AuthType as A, Credentials as C, GetRestCallAuthParamsProps as G, HostConfig as H, RestCallAuthParams as R, WebSocketAuthParams as W, AuthModule as a, GetWebSocketAuthParamsProps as b, GetWebResourceAuthParamsProps as c, WebResourceAuthParams as d, GetRemoteAuthDataProps as e, HandleAuthenticationErrorProps as f, AuthenticationErrorAction as g };
+export { type AuthType as A, type Credentials as C, type GetRestCallAuthParamsProps as G, type HostConfig as H, type RestCallAuthParams as R, type WebResourceAuthParams as W, type AuthModule as a, type GetWebSocketAuthParamsProps as b, type WebSocketAuthParams as c, type GetWebResourceAuthParamsProps as d, type GetRemoteAuthDataProps as e, type HandleAuthenticationErrorProps as f, type AuthenticationErrorAction as g, type HostConfigCommon as h, hostConfigCommonProperties as i, type AuthTypeThatCanBeOmitted as j, authTypesThatCanBeOmitted as k };

package/auth.d.ts

@@ -1,5 +1,5 @@
-import { A as AuthType, a as AuthModule, H as HostConfig } from './auth-types-DqfMuSRX.js';
-export { g as AuthenticationErrorAction, C as Credentials, e as GetRemoteAuthDataProps, G as GetRestCallAuthParamsProps, c as GetWebResourceAuthParamsProps, b as GetWebSocketAuthParamsProps, f as HandleAuthenticationErrorProps, R as RestCallAuthParams, d as WebResourceAuthParams, W as WebSocketAuthParams } from './auth-types-DqfMuSRX.js';
+import { A as AuthType, a as AuthModule, H as HostConfig, W as WebResourceAuthParams } from './auth-types-Cj5bM3Yk.js';
+export { j as AuthTypeThatCanBeOmitted, g as AuthenticationErrorAction, C as Credentials, e as GetRemoteAuthDataProps, G as GetRestCallAuthParamsProps, d as GetWebResourceAuthParamsProps, b as GetWebSocketAuthParamsProps, f as HandleAuthenticationErrorProps, h as HostConfigCommon, R as RestCallAuthParams, c as WebSocketAuthParams, k as authTypesThatCanBeOmitted, i as hostConfigCommonProperties } from './auth-types-Cj5bM3Yk.js';
 
 /**
  * Registers an auth module that can handle authentication. An auth module is used by specifying its name as authType in the HostConfig passed in to api calls.
@@ -36,7 +36,14 @@ declare function getAccessToken({ hostConfig }: {
     hostConfig?: HostConfig;
 }): Promise<string>;
 /**
- * The AuthApi interface provides the public interface for the auth module.
+ * Returns a record of query parameters that needs to be added to resources requests, e.g.
+ * image tags, etc.
+ */
+declare function getWebResourceAuthParams({ hostConfig, }: {
+    hostConfig?: HostConfig;
+}): Promise<WebResourceAuthParams>;
+/**
+ * The AuthAPI interface provides the public interface for the auth module.
  */
 interface AuthAPI {
     /**
@@ -65,6 +72,11 @@ interface AuthAPI {
      * Returns an access token using the supplied host config. Typically used on the backend to supply the access token to the frontend
      */
     getAccessToken: typeof getAccessToken;
+    /**
+     * Returns a record of query parameters that needs to be added to resources requests, e.g.
+     * image tags, etc.
+     */
+    getWebResourceAuthParams: typeof getWebResourceAuthParams;
 }
 declare const _default: {
     registerAuthModule: typeof registerAuthModule;
@@ -72,6 +84,7 @@ declare const _default: {
     registerHostConfig: typeof registerHostConfig;
     unregisterHostConfig: typeof unregisterHostConfig;
     getAccessToken: typeof getAccessToken;
+    getWebResourceAuthParams: typeof getWebResourceAuthParams;
 };
 
-export { type AuthAPI, AuthModule, AuthType, HostConfig, _default as default, getAccessToken, logout, registerAuthModule, registerHostConfig, setDefaultHostConfig, unregisterHostConfig };
+export { type AuthAPI, AuthModule, AuthType, HostConfig, WebResourceAuthParams, _default as default, getAccessToken, getWebResourceAuthParams, logout, registerAuthModule, registerHostConfig, setDefaultHostConfig, unregisterHostConfig };

package/auth.js

@@ -1,16 +1,18 @@
 import {
   auth_default,
   getAccessToken,
+  getWebResourceAuthParams,
   logout,
   registerAuthModule,
   registerHostConfig,
   setDefaultHostConfig,
   unregisterHostConfig
-} from "./chunks/GUU3KZGK.js";
-import "./chunks/DLKLPD7T.js";
+} from "./chunks/SPATCXXU.js";
+import "./chunks/GPRUNZV4.js";
 export {
   auth_default as default,
   getAccessToken,
+  getWebResourceAuthParams,
   logout,
   registerAuthModule,
   registerHostConfig,