@qlik/api 1.30.0 → 1.32.0

package/ml.js

@@ -0,0 +1,384 @@
+import {
+  clearApiCache,
+  invokeFetch
+} from "./chunks/VVD2DPKQ.js";
+import "./chunks/LTNGXTXG.js";
+import "./chunks/2ZQ3ZX7F.js";
+
+// src/public/rest/ml.ts
+var getMlDeployments = async (query, options) => invokeFetch("ml", {
+  method: "get",
+  pathTemplate: "/api/v1/ml/deployments",
+  query,
+  options
+});
+var createMlDeployment = async (body, options) => invokeFetch("ml", {
+  method: "post",
+  pathTemplate: "/api/v1/ml/deployments",
+  body,
+  contentType: "application/json",
+  options
+});
+var deleteMlDeployment = async (deploymentId, options) => invokeFetch("ml", {
+  method: "delete",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}",
+  pathVariables: { deploymentId },
+  options
+});
+var getMlDeployment = async (deploymentId, options) => invokeFetch("ml", {
+  method: "get",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}",
+  pathVariables: { deploymentId },
+  options
+});
+var patchMlDeployment = async (deploymentId, body, options) => invokeFetch("ml", {
+  method: "patch",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}",
+  pathVariables: { deploymentId },
+  body,
+  contentType: "application/json",
+  options
+});
+var activateModelsMlDeployment = async (deploymentId, options) => invokeFetch("ml", {
+  method: "post",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/actions/activate-models",
+  pathVariables: { deploymentId },
+  options
+});
+var deactivateModelsMlDeployment = async (deploymentId, options) => invokeFetch("ml", {
+  method: "post",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/actions/deactivate-models",
+  pathVariables: { deploymentId },
+  options
+});
+var getMlDeploymentAliases = async (deploymentId, query, options) => invokeFetch("ml", {
+  method: "get",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/aliases",
+  pathVariables: { deploymentId },
+  query,
+  options
+});
+var createMlDeploymentAliase = async (deploymentId, body, options) => invokeFetch("ml", {
+  method: "post",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/aliases",
+  pathVariables: { deploymentId },
+  body,
+  contentType: "application/json",
+  options
+});
+var deleteMlDeploymentAliase = async (deploymentId, aliasId, options) => invokeFetch("ml", {
+  method: "delete",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/aliases/{aliasId}",
+  pathVariables: { deploymentId, aliasId },
+  options
+});
+var getMlDeploymentAliase = async (deploymentId, aliasId, options) => invokeFetch("ml", {
+  method: "get",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/aliases/{aliasId}",
+  pathVariables: { deploymentId, aliasId },
+  options
+});
+var patchMlDeploymentAliase = async (deploymentId, aliasId, body, options) => invokeFetch("ml", {
+  method: "patch",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/aliases/{aliasId}",
+  pathVariables: { deploymentId, aliasId },
+  body,
+  contentType: "application/json",
+  options
+});
+var runMlDeploymentAliaseRealtimePredictions = async (deploymentId, aliasName, query, body, options) => invokeFetch("ml", {
+  method: "post",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/aliases/{aliasName}/realtime-predictions/actions/run",
+  pathVariables: { deploymentId, aliasName },
+  query,
+  body,
+  contentType: "application/json",
+  options
+});
+var getMlDeploymentBatchPredictions = async (deploymentId, query, options) => invokeFetch("ml", {
+  method: "get",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/batch-predictions",
+  pathVariables: { deploymentId },
+  query,
+  options
+});
+var createMlDeploymentBatchPrediction = async (deploymentId, body, options) => invokeFetch("ml", {
+  method: "post",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/batch-predictions",
+  pathVariables: { deploymentId },
+  body,
+  contentType: "application/json",
+  options
+});
+var deleteMlDeploymentBatchPrediction = async (deploymentId, batchPredictionId, options) => invokeFetch("ml", {
+  method: "delete",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/batch-predictions/{batchPredictionId}",
+  pathVariables: { deploymentId, batchPredictionId },
+  options
+});
+var getMlDeploymentBatchPrediction = async (deploymentId, batchPredictionId, options) => invokeFetch("ml", {
+  method: "get",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/batch-predictions/{batchPredictionId}",
+  pathVariables: { deploymentId, batchPredictionId },
+  options
+});
+var patchMlDeploymentBatchPrediction = async (deploymentId, batchPredictionId, body, options) => invokeFetch("ml", {
+  method: "patch",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/batch-predictions/{batchPredictionId}",
+  pathVariables: { deploymentId, batchPredictionId },
+  body,
+  contentType: "application/json",
+  options
+});
+var predictMlDeploymentBatchPrediction = async (deploymentId, batchPredictionId, options) => invokeFetch("ml", {
+  method: "post",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/batch-predictions/{batchPredictionId}/actions/predict",
+  pathVariables: { deploymentId, batchPredictionId },
+  options
+});
+var deleteMlDeploymentBatchPredictionSchedule = async (deploymentId, batchPredictionId, options) => invokeFetch("ml", {
+  method: "delete",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/batch-predictions/{batchPredictionId}/schedule",
+  pathVariables: { deploymentId, batchPredictionId },
+  options
+});
+var getMlDeploymentBatchPredictionSchedule = async (deploymentId, batchPredictionId, options) => invokeFetch("ml", {
+  method: "get",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/batch-predictions/{batchPredictionId}/schedule",
+  pathVariables: { deploymentId, batchPredictionId },
+  options
+});
+var updateMlDeploymentBatchPredictionSchedule = async (deploymentId, batchPredictionId, body, options) => invokeFetch("ml", {
+  method: "patch",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/batch-predictions/{batchPredictionId}/schedule",
+  pathVariables: { deploymentId, batchPredictionId },
+  body,
+  contentType: "application/json",
+  options
+});
+var setMlDeploymentBatchPredictionSchedule = async (deploymentId, batchPredictionId, body, options) => invokeFetch("ml", {
+  method: "put",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/batch-predictions/{batchPredictionId}/schedule",
+  pathVariables: { deploymentId, batchPredictionId },
+  body,
+  contentType: "application/json",
+  options
+});
+var addMlDeploymentModels = async (deploymentId, body, options) => invokeFetch("ml", {
+  method: "post",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/models/actions/add",
+  pathVariables: { deploymentId },
+  body,
+  contentType: "application/json",
+  options
+});
+var removeMlDeploymentModels = async (deploymentId, body, options) => invokeFetch("ml", {
+  method: "post",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/models/actions/remove",
+  pathVariables: { deploymentId },
+  body,
+  contentType: "application/json",
+  options
+});
+var runMlDeploymentRealtimePredictions = async (deploymentId, query, body, options) => invokeFetch("ml", {
+  method: "post",
+  pathTemplate: "/api/v1/ml/deployments/{deploymentId}/realtime-predictions/actions/run",
+  pathVariables: { deploymentId },
+  query,
+  body,
+  contentType: "application/json",
+  options
+});
+var getMlExperiments = async (query, options) => invokeFetch("ml", {
+  method: "get",
+  pathTemplate: "/api/v1/ml/experiments",
+  query,
+  options
+});
+var createMlExperiment = async (body, options) => invokeFetch("ml", {
+  method: "post",
+  pathTemplate: "/api/v1/ml/experiments",
+  body,
+  contentType: "application/json",
+  options
+});
+var deleteMlExperiment = async (experimentId, options) => invokeFetch("ml", {
+  method: "delete",
+  pathTemplate: "/api/v1/ml/experiments/{experimentId}",
+  pathVariables: { experimentId },
+  options
+});
+var getMlExperiment = async (experimentId, options) => invokeFetch("ml", {
+  method: "get",
+  pathTemplate: "/api/v1/ml/experiments/{experimentId}",
+  pathVariables: { experimentId },
+  options
+});
+var patchMlExperiment = async (experimentId, body, options) => invokeFetch("ml", {
+  method: "patch",
+  pathTemplate: "/api/v1/ml/experiments/{experimentId}",
+  pathVariables: { experimentId },
+  body,
+  contentType: "application/json",
+  options
+});
+var getMlExperimentModels = async (experimentId, query, options) => invokeFetch("ml", {
+  method: "get",
+  pathTemplate: "/api/v1/ml/experiments/{experimentId}/models",
+  pathVariables: { experimentId },
+  query,
+  options
+});
+var getMlExperimentModel = async (experimentId, modelId, options) => invokeFetch("ml", {
+  method: "get",
+  pathTemplate: "/api/v1/ml/experiments/{experimentId}/models/{modelId}",
+  pathVariables: { experimentId, modelId },
+  options
+});
+var getMlExperimentVersions = async (experimentId, query, options) => invokeFetch("ml", {
+  method: "get",
+  pathTemplate: "/api/v1/ml/experiments/{experimentId}/versions",
+  pathVariables: { experimentId },
+  query,
+  options
+});
+var createMlExperimentVersion = async (experimentId, body, options) => invokeFetch("ml", {
+  method: "post",
+  pathTemplate: "/api/v1/ml/experiments/{experimentId}/versions",
+  pathVariables: { experimentId },
+  body,
+  contentType: "application/json",
+  options
+});
+var deleteMlExperimentVersion = async (experimentId, experimentVersionId, options) => invokeFetch("ml", {
+  method: "delete",
+  pathTemplate: "/api/v1/ml/experiments/{experimentId}/versions/{experimentVersionId}",
+  pathVariables: { experimentId, experimentVersionId },
+  options
+});
+var getMlExperimentVersion = async (experimentId, experimentVersionId, options) => invokeFetch("ml", {
+  method: "get",
+  pathTemplate: "/api/v1/ml/experiments/{experimentId}/versions/{experimentVersionId}",
+  pathVariables: { experimentId, experimentVersionId },
+  options
+});
+var patchMlExperimentVersion = async (experimentId, experimentVersionId, body, options) => invokeFetch("ml", {
+  method: "patch",
+  pathTemplate: "/api/v1/ml/experiments/{experimentId}/versions/{experimentVersionId}",
+  pathVariables: { experimentId, experimentVersionId },
+  body,
+  contentType: "application/json",
+  options
+});
+var cancelMlJob = async (corrType, corrId, options) => invokeFetch("ml", {
+  method: "post",
+  pathTemplate: "/api/v1/ml/jobs/{corrType}/{corrId}/actions/cancel",
+  pathVariables: { corrType, corrId },
+  options
+});
+var createMlProfileInsight = async (body, options) => invokeFetch("ml", {
+  method: "post",
+  pathTemplate: "/api/v1/ml/profile-insights",
+  body,
+  contentType: "application/json",
+  options
+});
+var getMlProfileInsight = async (dataSetId, options) => invokeFetch("ml", {
+  method: "get",
+  pathTemplate: "/api/v1/ml/profile-insights/{dataSetId}",
+  pathVariables: { dataSetId },
+  options
+});
+function clearCache() {
+  return clearApiCache("ml");
+}
+var mlExport = {
+  getMlDeployments,
+  createMlDeployment,
+  deleteMlDeployment,
+  getMlDeployment,
+  patchMlDeployment,
+  activateModelsMlDeployment,
+  deactivateModelsMlDeployment,
+  getMlDeploymentAliases,
+  createMlDeploymentAliase,
+  deleteMlDeploymentAliase,
+  getMlDeploymentAliase,
+  patchMlDeploymentAliase,
+  runMlDeploymentAliaseRealtimePredictions,
+  getMlDeploymentBatchPredictions,
+  createMlDeploymentBatchPrediction,
+  deleteMlDeploymentBatchPrediction,
+  getMlDeploymentBatchPrediction,
+  patchMlDeploymentBatchPrediction,
+  predictMlDeploymentBatchPrediction,
+  deleteMlDeploymentBatchPredictionSchedule,
+  getMlDeploymentBatchPredictionSchedule,
+  updateMlDeploymentBatchPredictionSchedule,
+  setMlDeploymentBatchPredictionSchedule,
+  addMlDeploymentModels,
+  removeMlDeploymentModels,
+  runMlDeploymentRealtimePredictions,
+  getMlExperiments,
+  createMlExperiment,
+  deleteMlExperiment,
+  getMlExperiment,
+  patchMlExperiment,
+  getMlExperimentModels,
+  getMlExperimentModel,
+  getMlExperimentVersions,
+  createMlExperimentVersion,
+  deleteMlExperimentVersion,
+  getMlExperimentVersion,
+  patchMlExperimentVersion,
+  cancelMlJob,
+  createMlProfileInsight,
+  getMlProfileInsight,
+  clearCache
+};
+var ml_default = mlExport;
+export {
+  activateModelsMlDeployment,
+  addMlDeploymentModels,
+  cancelMlJob,
+  clearCache,
+  createMlDeployment,
+  createMlDeploymentAliase,
+  createMlDeploymentBatchPrediction,
+  createMlExperiment,
+  createMlExperimentVersion,
+  createMlProfileInsight,
+  deactivateModelsMlDeployment,
+  ml_default as default,
+  deleteMlDeployment,
+  deleteMlDeploymentAliase,
+  deleteMlDeploymentBatchPrediction,
+  deleteMlDeploymentBatchPredictionSchedule,
+  deleteMlExperiment,
+  deleteMlExperimentVersion,
+  getMlDeployment,
+  getMlDeploymentAliase,
+  getMlDeploymentAliases,
+  getMlDeploymentBatchPrediction,
+  getMlDeploymentBatchPredictionSchedule,
+  getMlDeploymentBatchPredictions,
+  getMlDeployments,
+  getMlExperiment,
+  getMlExperimentModel,
+  getMlExperimentModels,
+  getMlExperimentVersion,
+  getMlExperimentVersions,
+  getMlExperiments,
+  getMlProfileInsight,
+  patchMlDeployment,
+  patchMlDeploymentAliase,
+  patchMlDeploymentBatchPrediction,
+  patchMlExperiment,
+  patchMlExperimentVersion,
+  predictMlDeploymentBatchPrediction,
+  removeMlDeploymentModels,
+  runMlDeploymentAliaseRealtimePredictions,
+  runMlDeploymentRealtimePredictions,
+  setMlDeploymentBatchPredictionSchedule,
+  updateMlDeploymentBatchPredictionSchedule
+};

package/notes.d.ts

@@ -0,0 +1,110 @@
+import { A as ApiCallOptions } from './invoke-fetch-types-Cq7bjkqn.js';
+import './auth-types-DqfMuSRX.js';
+
+/**
+ * The possible states for the status of notes configuration GET or POST operation
+ */
+type ConfigReasonCode = "deployment" | "toggle" | "license";
+type Error = {
+    /** Error code specific to notes broker service. */
+    readonly code?: string;
+    /** Error cause. */
+    readonly detail?: string;
+    /** Error title. */
+    readonly title?: string;
+};
+/**
+ * @example
+ * {
+ *   errors: [
+ *     {
+ *       code: "HTTP-123",
+ *       title: "short error message"
+ *     }
+ *   ],
+ *   traceId: "7326ce0d-1946-41d0-b890-609865cc42ea"
+ * }
+ */
+type Errors = {
+    errors?: Error[];
+    /** An optional traceId */
+    traceId?: string;
+};
+type NoteSettingsPutPayload = {
+    /** pass 'true' to enable the note toggle for the tenant, 'false' to disable the toggle (other values are ignore). */
+    toggledOn?: boolean;
+};
+type NoteSettingsPutResponse = {
+    /** 'true' if the note feature is enabled for this tenant and user otherwise 'false'. */
+    toggleOn?: boolean;
+};
+type NotesUserSettings = {
+    /** 'true' if the note feature is enabled for this tenant and user otherwise 'false'. */
+    available: boolean;
+    /** The timestamp for the last time this users notes settings were fetched from downstream services. */
+    lastFetch?: string;
+    /** The possible states for the status of notes configuration GET or POST operation */
+    reason?: ConfigReasonCode;
+};
+/**
+ * Get the enablement status of the notes feature set for this tenant and user.
+ *
+ * @throws GetNotesSettingsHttpError
+ */
+declare const getNotesSettings: (options?: ApiCallOptions) => Promise<GetNotesSettingsHttpResponse>;
+type GetNotesSettingsHttpResponse = {
+    data: NotesUserSettings;
+    headers: Headers;
+    status: 200;
+};
+type GetNotesSettingsHttpError = {
+    data: Errors;
+    headers: Headers;
+    status: number;
+};
+/**
+ * update the settings
+ *
+ * @param body an object with the body content
+ * @throws SetNotesSettingsHttpError
+ */
+declare const setNotesSettings: (body: NoteSettingsPutPayload, options?: ApiCallOptions) => Promise<SetNotesSettingsHttpResponse>;
+type SetNotesSettingsHttpResponse = {
+    data: NoteSettingsPutResponse;
+    headers: Headers;
+    status: 200;
+};
+type SetNotesSettingsHttpError = {
+    data: Errors;
+    headers: Headers;
+    status: number;
+};
+/**
+ * Clears the cache for notes api requests.
+ */
+declare function clearCache(): void;
+interface NotesAPI {
+    /**
+     * Get the enablement status of the notes feature set for this tenant and user.
+     *
+     * @throws GetNotesSettingsHttpError
+     */
+    getNotesSettings: typeof getNotesSettings;
+    /**
+     * update the settings
+     *
+     * @param body an object with the body content
+     * @throws SetNotesSettingsHttpError
+     */
+    setNotesSettings: typeof setNotesSettings;
+    /**
+     * Clears the cache for notes api requests.
+     */
+    clearCache: typeof clearCache;
+}
+/**
+ * Functions for the notes api
+ */
+declare const notesExport: NotesAPI;
+
+export { type ConfigReasonCode, type Error, type Errors, type GetNotesSettingsHttpError, type GetNotesSettingsHttpResponse, type NoteSettingsPutPayload, type NoteSettingsPutResponse, type NotesAPI, type NotesUserSettings, type SetNotesSettingsHttpError, type SetNotesSettingsHttpResponse, clearCache, notesExport as default, getNotesSettings, setNotesSettings };

package/notes.js

@@ -0,0 +1,31 @@
+import {
+  clearApiCache,
+  invokeFetch
+} from "./chunks/VVD2DPKQ.js";
+import "./chunks/LTNGXTXG.js";
+import "./chunks/2ZQ3ZX7F.js";
+
+// src/public/rest/notes.ts
+var getNotesSettings = async (options) => invokeFetch("notes", {
+  method: "get",
+  pathTemplate: "/api/v1/notes/settings",
+  options
+});
+var setNotesSettings = async (body, options) => invokeFetch("notes", {
+  method: "put",
+  pathTemplate: "/api/v1/notes/settings",
+  body,
+  contentType: "application/json",
+  options
+});
+function clearCache() {
+  return clearApiCache("notes");
+}
+var notesExport = { getNotesSettings, setNotesSettings, clearCache };
+var notes_default = notesExport;
+export {
+  clearCache,
+  notes_default as default,
+  getNotesSettings,
+  setNotesSettings
+};

package/notifications.d.ts

@@ -0,0 +1,98 @@
+import { A as ApiCallOptions } from './invoke-fetch-types-Cq7bjkqn.js';
+import './auth-types-DqfMuSRX.js';
+
+/**
+ * An error object.
+ */
+type Error = {
+    /** The error code. */
+    code: string;
+    /** A human-readable explanation specific to this occurrence of the problem. */
+    detail?: string;
+    /** Summary of the problem. */
+    title: string;
+};
+/**
+ * Notification result item
+ */
+type NotificationItem = {
+    /** Indicates if the notification can be managed in the hub. If true, the object will also contain 'subscriptionInfo' object and a 'presentationInfo' object with a non-empty scopes array. */
+    isManageableInHub?: boolean;
+    /** Indicates if the notification can be subscribed to by users.  If true, the object will also contain 'subscriptionInfo' object */
+    isSubscribable: boolean;
+    /** Notification name pattern that will trigger this notification e.g resource.action */
+    notificationNamePattern: string;
+    /** Object containing information pertaining to the presentaion of a notification in the UI */
+    presentationInfo?: {
+        /** Localized, human-readable string representing the name of the notification suitable to use in a UI */
+        friendlyName?: string;
+        /** Friendly name to be displayed for each scope. */
+        scopeFriendlyNames?: Record<string, string>;
+        /** Information about the scopes to which this notification applies.  Helps determine the placement of the notification in the UI */
+        scopes?: string[];
+    };
+    /** Object indicating what properties to use to subscribe to this notification via the 'Subscriptions' service.  For info about its properties, refer to the Subscription sevice's API doc. */
+    subscriptionInfo?: {
+        action: string;
+        resourceId?: string;
+        resourceSubType?: string;
+        resourceType: string;
+        target?: string;
+    };
+    /** Type of Transport e.g. Email, Notification, Slack message etc... */
+    transports: string[];
+};
+/**
+ * Object containing array representing list of supported notifications
+ */
+type NotificationsObject = {
+    /** list of notifications */
+    notifications: NotificationItem[];
+};
+/**
+ * List all supported notifications
+ *
+ * @param query an object with query parameters
+ * @throws GetNotificationsHttpError
+ */
+declare const getNotifications: (query: {
+    /** If present, idenfies the language of the returned 'friendlyName' property. */
+    locale?: string;
+    /** If present, represents the 'manageableInHub' value to filter by. */
+    manageableInHub?: true | false;
+    /** If present, represents the 'subscribable' value to filter by. */
+    subscribable?: true | false;
+}, options?: ApiCallOptions) => Promise<GetNotificationsHttpResponse>;
+type GetNotificationsHttpResponse = {
+    data: NotificationsObject;
+    headers: Headers;
+    status: 200;
+};
+type GetNotificationsHttpError = {
+    data: Error;
+    headers: Headers;
+    status: number;
+};
+/**
+ * Clears the cache for notifications api requests.
+ */
+declare function clearCache(): void;
+interface NotificationsAPI {
+    /**
+     * List all supported notifications
+     *
+     * @param query an object with query parameters
+     * @throws GetNotificationsHttpError
+     */
+    getNotifications: typeof getNotifications;
+    /**
+     * Clears the cache for notifications api requests.
+     */
+    clearCache: typeof clearCache;
+}
+/**
+ * Functions for the notifications api
+ */
+declare const notificationsExport: NotificationsAPI;
+
+export { type Error, type GetNotificationsHttpError, type GetNotificationsHttpResponse, type NotificationItem, type NotificationsAPI, type NotificationsObject, clearCache, notificationsExport as default, getNotifications };

package/notifications.js

@@ -0,0 +1,24 @@
+import {
+  clearApiCache,
+  invokeFetch
+} from "./chunks/VVD2DPKQ.js";
+import "./chunks/LTNGXTXG.js";
+import "./chunks/2ZQ3ZX7F.js";
+
+// src/public/rest/notifications.ts
+var getNotifications = async (query, options) => invokeFetch("notifications", {
+  method: "get",
+  pathTemplate: "/api/v1/notifications",
+  query,
+  options
+});
+function clearCache() {
+  return clearApiCache("notifications");
+}
+var notificationsExport = { getNotifications, clearCache };
+var notifications_default = notificationsExport;
+export {
+  clearCache,
+  notifications_default as default,
+  getNotifications
+};

package/oauth-clients.d.ts

@@ -1,5 +1,5 @@
-import { A as ApiCallOptions } from './invoke-fetch-types-BXn-uSF5.js';
-import './auth-types-PkN9CAF_.js';
+import { A as ApiCallOptions } from './invoke-fetch-types-Cq7bjkqn.js';
+import './auth-types-DqfMuSRX.js';
 
 /**
  * Hints of any client application secrets
@@ -123,6 +123,11 @@ type OAuthClientCreateRequest = {
     clientName: string;
     /** URI for homepage of client */
     clientUri?: string;
+    /** Optional settings for configuring the client connection. */
+    connectionConfig?: {
+        /** Specifies the consent method for the connection. The only allowed value is "trusted." */
+        consentMethod?: "trusted";
+    };
     /** Client description */
     description?: string;
     /** URI for logo of client */

package/oauth-clients.js

@@ -1,8 +1,8 @@
 import {
   clearApiCache,
   invokeFetch
-} from "./chunks/PTDXR7AY.js";
-import "./chunks/TXC5XORK.js";
+} from "./chunks/VVD2DPKQ.js";
+import "./chunks/LTNGXTXG.js";
 import "./chunks/2ZQ3ZX7F.js";
 
 // src/public/rest/oauth-clients.ts