@japro/luma-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,382 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  LumaClient: () => LumaClient,
+  createLumaClient: () => createLumaClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/api/generated-api.ts
+var import_axios = __toESM(require("axios"), 1);
+var HttpClient = class {
+  constructor({
+    securityWorker,
+    secure,
+    format,
+    ...axiosConfig
+  } = {}) {
+    this.securityData = null;
+    this.setSecurityData = (data) => {
+      this.securityData = data;
+    };
+    this.request = async ({
+      secure,
+      path,
+      type,
+      query,
+      format,
+      body,
+      ...params
+    }) => {
+      const secureParams = (typeof secure === "boolean" ? secure : this.secure) && this.securityWorker && await this.securityWorker(this.securityData) || {};
+      const requestParams = this.mergeRequestParams(params, secureParams);
+      const responseFormat = format || this.format || void 0;
+      if (type === "multipart/form-data" /* FormData */ && body && body !== null && typeof body === "object") {
+        body = this.createFormData(body);
+      }
+      if (type === "text/plain" /* Text */ && body && body !== null && typeof body !== "string") {
+        body = JSON.stringify(body);
+      }
+      return this.instance.request({
+        ...requestParams,
+        headers: {
+          ...requestParams.headers || {},
+          ...type ? { "Content-Type": type } : {}
+        },
+        params: query,
+        responseType: responseFormat,
+        data: body,
+        url: path
+      });
+    };
+    this.instance = import_axios.default.create({
+      ...axiosConfig,
+      baseURL: axiosConfig.baseURL || ""
+    });
+    this.secure = secure;
+    this.format = format;
+    this.securityWorker = securityWorker;
+  }
+  mergeRequestParams(params1, params2) {
+    const method = params1.method || params2 && params2.method;
+    return {
+      ...this.instance.defaults,
+      ...params1,
+      ...params2 || {},
+      headers: {
+        ...method && this.instance.defaults.headers[method.toLowerCase()] || {},
+        ...params1.headers || {},
+        ...params2 && params2.headers || {}
+      }
+    };
+  }
+  stringifyFormItem(formItem) {
+    if (typeof formItem === "object" && formItem !== null) {
+      return JSON.stringify(formItem);
+    } else {
+      return `${formItem}`;
+    }
+  }
+  createFormData(input) {
+    if (input instanceof FormData) {
+      return input;
+    }
+    return Object.keys(input || {}).reduce((formData, key) => {
+      const property = input[key];
+      const propertyContent = property instanceof Array ? property : [property];
+      for (const formItem of propertyContent) {
+        const isFileType = formItem instanceof Blob || formItem instanceof File;
+        formData.append(
+          key,
+          isFileType ? formItem : this.stringifyFormItem(formItem)
+        );
+      }
+      return formData;
+    }, new FormData());
+  }
+};
+var API = class extends HttpClient {
+  constructor() {
+    super(...arguments);
+    this.api = {
+      /**
+       * @description Streams AI chat responses for the draft associated with `integration_id` (the external course identifier you are building a draft for), scoped to the organization resolved from `X-API-Key`. Authorization header required: `X-API-Key: <luma_api_key>`.
+       *
+       * @tags Public - Require API Key
+       * @name ChatApiPublicV1AiChatIntegrationIdPost
+       * @summary Chat With Draft By Integration ID
+       * @request POST:/api/public/v1/ai/chat/{integration_id}
+       * @secure
+       */
+      chatApiPublicV1AiChatIntegrationIdPost: (integrationId, data, params = {}) => this.request({
+        path: `/api/public/v1/ai/chat/${integrationId}`,
+        method: "POST",
+        body: data,
+        secure: true,
+        type: "application/json" /* Json */,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Creates a draft for a given `integration_id` (the external course identifier you are building a draft for) under the organization resolved from `X-API-Key`. Authorization header required: `X-API-Key: <luma_api_key>`.
+       *
+       * @tags Public - Require API Key
+       * @name CreateDraftApiPublicV1DraftPost
+       * @summary Create Draft By Integration ID
+       * @request POST:/api/public/v1/draft
+       * @secure
+       */
+      createDraftApiPublicV1DraftPost: (data, params = {}) => this.request({
+        path: `/api/public/v1/draft`,
+        method: "POST",
+        body: data,
+        secure: true,
+        type: "application/json" /* Json */,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Uploads a file to the draft associated with `integration_id` (the external course identifier you are building a draft for), scoped to the organization resolved from `X-API-Key`. Authorization header required: `X-API-Key: <luma_api_key>`.
+       *
+       * @tags Public - Require API Key
+       * @name IngestApiPublicV1DraftIngestIntegrationIdPost
+       * @summary Ingest File To Draft By Integration ID
+       * @request POST:/api/public/v1/draft/ingest/{integration_id}
+       * @secure
+       */
+      ingestApiPublicV1DraftIngestIntegrationIdPost: (integrationId, data, params = {}) => this.request({
+        path: `/api/public/v1/draft/ingest/${integrationId}`,
+        method: "POST",
+        body: data,
+        secure: true,
+        type: "multipart/form-data" /* FormData */,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Removes a previously ingested document from the draft associated with `integration_id` (the external course identifier you are building a draft for), scoped to the organization resolved from `X-API-Key`. Authorization header required: `X-API-Key: <luma_api_key>`.
+       *
+       * @tags Public - Require API Key
+       * @name DeleteIngestedDocumentApiPublicV1DraftIngestIntegrationIdDocumentIdDelete
+       * @summary Delete Ingested Document By Integration ID
+       * @request DELETE:/api/public/v1/draft/ingest/{integration_id}/{document_id}
+       * @secure
+       */
+      deleteIngestedDocumentApiPublicV1DraftIngestIntegrationIdDocumentIdDelete: (integrationId, documentId, params = {}) => this.request({
+        path: `/api/public/v1/draft/ingest/${integrationId}/${documentId}`,
+        method: "DELETE",
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Returns all files linked to the draft for the provided `integration_id` (the external course identifier you are building a draft for), scoped to the organization resolved from `X-API-Key`. Authorization header required: `X-API-Key: <luma_api_key>`.
+       *
+       * @tags Public - Require API Key
+       * @name GetDraftFilesApiPublicV1DraftFilesIntegrationIdGet
+       * @summary Get Draft Files By Integration ID
+       * @request GET:/api/public/v1/draft/files/{integration_id}
+       * @secure
+       */
+      getDraftFilesApiPublicV1DraftFilesIntegrationIdGet: (integrationId, params = {}) => this.request({
+        path: `/api/public/v1/draft/files/${integrationId}`,
+        method: "GET",
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Fetches draft status for the provided `integration_id` (the external course identifier you are building a draft for) inside the organization resolved from `X-API-Key`. Authorization header required: `X-API-Key: <luma_api_key>`.
+       *
+       * @tags Public - Require API Key
+       * @name GetDraftApiPublicV1DraftIntegrationIdGet
+       * @summary Get Draft Status By Integration ID
+       * @request GET:/api/public/v1/draft/{integration_id}
+       * @secure
+       */
+      getDraftApiPublicV1DraftIntegrationIdGet: (integrationId, params = {}) => this.request({
+        path: `/api/public/v1/draft/${integrationId}`,
+        method: "GET",
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Returns all draft chat messages for the draft associated with `integration_id` (the external course identifier you are building a draft for), scoped to the organization resolved from `X-API-Key`. Authorization header required: `X-API-Key: <luma_api_key>`.
+       *
+       * @tags Public - Require API Key
+       * @name GetDraftMessagesApiPublicV1DraftMessagesIntegrationIdGet
+       * @summary Get Draft Messages By Integration ID
+       * @request GET:/api/public/v1/draft/messages/{integration_id}
+       * @secure
+       */
+      getDraftMessagesApiPublicV1DraftMessagesIntegrationIdGet: (integrationId, params = {}) => this.request({
+        path: `/api/public/v1/draft/messages/${integrationId}`,
+        method: "GET",
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Returns the generated course payload for the draft associated with `integration_id` (the external course identifier you are building a draft for), scoped to the organization resolved from `X-API-Key`. Authorization header required: `X-API-Key: <luma_api_key>`.
+       *
+       * @tags Public - Require API Key
+       * @name GetGeneratedCourseApiPublicV1DraftGeneratedCourseIntegrationIdGet
+       * @summary Get Generated Course By Integration ID
+       * @request GET:/api/public/v1/draft/generated-course/{integration_id}
+       * @secure
+       */
+      getGeneratedCourseApiPublicV1DraftGeneratedCourseIntegrationIdGet: (integrationId, params = {}) => this.request({
+        path: `/api/public/v1/draft/generated-course/${integrationId}`,
+        method: "GET",
+        secure: true,
+        format: "json",
+        ...params
+      })
+    };
+  }
+};
+
+// src/client.ts
+var import_node_https = require("https");
+
+// src/executions/public-api-executions.ts
+var PublicApiExecutions = class {
+  constructor(apiClient) {
+    this.apiClient = apiClient;
+  }
+  async chat(opts) {
+    return this.apiClient.api.chatApiPublicV1AiChatIntegrationIdPost(
+      opts.integrationId,
+      {
+        message: opts.message
+      },
+      {
+        format: "stream"
+      }
+    );
+  }
+  async createDraft(opts) {
+    const response = await this.apiClient.api.createDraftApiPublicV1DraftPost(opts);
+    return response.data;
+  }
+  async ingestDraftFile(opts) {
+    const response = await this.apiClient.api.ingestApiPublicV1DraftIngestIntegrationIdPost(
+      opts.integrationId,
+      {
+        file: opts.file
+      }
+    );
+    return response.data;
+  }
+  async deleteIngestedDocument(opts) {
+    const response = await this.apiClient.api.deleteIngestedDocumentApiPublicV1DraftIngestIntegrationIdDocumentIdDelete(
+      opts.integrationId,
+      opts.documentId
+    );
+    return response.data;
+  }
+  async getDraftFiles(opts) {
+    const response = await this.apiClient.api.getDraftFilesApiPublicV1DraftFilesIntegrationIdGet(
+      opts.integrationId
+    );
+    return response.data;
+  }
+  async getDraft(opts) {
+    const response = await this.apiClient.api.getDraftApiPublicV1DraftIntegrationIdGet(
+      opts.integrationId
+    );
+    return response.data;
+  }
+  async getDraftMessages(opts) {
+    const response = await this.apiClient.api.getDraftMessagesApiPublicV1DraftMessagesIntegrationIdGet(
+      opts.integrationId
+    );
+    return response.data;
+  }
+  async getGeneratedCourse(opts) {
+    const response = await this.apiClient.api.getGeneratedCourseApiPublicV1DraftGeneratedCourseIntegrationIdGet(
+      opts.integrationId
+    );
+    return response.data;
+  }
+};
+
+// src/client.ts
+var LumaClient = class {
+  constructor(opts) {
+    const httpsAgent = opts.httpsAgent ?? (opts.allowInsecureTls ? new import_node_https.Agent({ rejectUnauthorized: false }) : void 0);
+    this.apiClient = new API({
+      baseURL: opts.baseURL,
+      secure: true,
+      httpsAgent,
+      headers: {
+        "X-API-Key": opts.apiKey
+      }
+    });
+    this.executions = new PublicApiExecutions(this.apiClient);
+  }
+  async chat(opts) {
+    return this.executions.chat(opts);
+  }
+  async createDraft(opts) {
+    return this.executions.createDraft(opts);
+  }
+  async ingestDraftFile(opts) {
+    return this.executions.ingestDraftFile(opts);
+  }
+  async deleteIngestedDocument(opts) {
+    return this.executions.deleteIngestedDocument(opts);
+  }
+  async getDraftFiles(opts) {
+    return this.executions.getDraftFiles(opts);
+  }
+  async getDraft(opts) {
+    return this.executions.getDraft(opts);
+  }
+  async getDraftMessages(opts) {
+    return this.executions.getDraftMessages(opts);
+  }
+  async getGeneratedCourse(opts) {
+    return this.executions.getGeneratedCourse(opts);
+  }
+};
+
+// src/index.ts
+var createLumaClient = (opts) => {
+  return new LumaClient(opts);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LumaClient,
+  createLumaClient
+});