cngkit 1.1.17 → 1.1.18

package/dist/{chunk-HRFI2IEP.js → chunk-FJ34NVQ4.js}

@@ -1,6 +1,6 @@
 import {
   resolveApiBaseUrl
-} from "./chunk-WYJTGGMN.js";
+} from "./chunk-CBIVTEZP.js";
 import {
   __export
 } from "./chunk-PZ5AY32C.js";
@@ -298,6 +298,15 @@ var HarnessSemanticSearchResponse;
   };
 })(HarnessSemanticSearchResponse || (HarnessSemanticSearchResponse = {}));
 
+// ../../packages/client/src/generated/api/types/HookifyIngestResponse.ts
+var HookifyIngestResponse;
+((HookifyIngestResponse2) => {
+  HookifyIngestResponse2.Mode = {
+    Sync: "sync",
+    Async: "async"
+  };
+})(HookifyIngestResponse || (HookifyIngestResponse = {}));
+
 // ../../packages/client/src/generated/core/headers.ts
 function mergeHeaders(...headersArray) {
   const result = {};
@@ -1447,6 +1456,174 @@ async function makePassthroughRequest(input, init, clientOptions, requestOptions
   return response;
 }
 
+// ../../packages/client/src/generated/core/file/index.ts
+var file_exports = {};
+__export(file_exports, {
+  toBinaryUploadRequest: () => toBinaryUploadRequest,
+  toMultipartDataPart: () => toMultipartDataPart
+});
+
+// ../../packages/client/src/generated/core/file/file.ts
+async function toBinaryUploadRequest(file) {
+  const { data, filename, contentLength, contentType } = await getFileWithMetadata(file);
+  const request = {
+    body: data,
+    headers: {}
+  };
+  if (filename) {
+    request.headers["Content-Disposition"] = `attachment; filename="${filename}"`;
+  }
+  if (contentType) {
+    request.headers["Content-Type"] = contentType;
+  }
+  if (contentLength != null) {
+    request.headers["Content-Length"] = contentLength.toString();
+  }
+  return request;
+}
+async function toMultipartDataPart(file) {
+  const { data, filename, contentType } = await getFileWithMetadata(file, {
+    noSniffFileSize: true
+  });
+  return {
+    data,
+    filename,
+    contentType
+  };
+}
+async function getFileWithMetadata(file, { noSniffFileSize } = {}) {
+  if (isFileLike(file)) {
+    return getFileWithMetadata(
+      {
+        data: file
+      },
+      { noSniffFileSize }
+    );
+  }
+  if ("path" in file) {
+    const fs = await import("fs");
+    if (!fs?.createReadStream) {
+      throw new Error("File path uploads are not supported in this environment.");
+    }
+    const data = fs.createReadStream(file.path);
+    const contentLength = file.contentLength ?? (noSniffFileSize === true ? void 0 : await tryGetFileSizeFromPath(file.path));
+    const filename = file.filename ?? getNameFromPath(file.path);
+    return {
+      data,
+      filename,
+      contentType: file.contentType,
+      contentLength
+    };
+  }
+  if ("data" in file) {
+    const data = file.data;
+    const contentLength = file.contentLength ?? await tryGetContentLengthFromFileLike(data, {
+      noSniffFileSize
+    });
+    const filename = file.filename ?? tryGetNameFromFileLike(data);
+    return {
+      data,
+      filename,
+      contentType: file.contentType ?? tryGetContentTypeFromFileLike(data),
+      contentLength
+    };
+  }
+  throw new Error(`Invalid FileUpload of type ${typeof file}: ${JSON.stringify(file)}`);
+}
+function isFileLike(value) {
+  return isBuffer(value) || isArrayBufferView(value) || isArrayBuffer(value) || isUint8Array(value) || isBlob(value) || isFile(value) || isStreamLike(value) || isReadableStream(value);
+}
+async function tryGetFileSizeFromPath(path) {
+  try {
+    const fs = await import("fs");
+    if (!fs?.promises?.stat) {
+      return void 0;
+    }
+    const fileStat = await fs.promises.stat(path);
+    return fileStat.size;
+  } catch (_fallbackError) {
+    return void 0;
+  }
+}
+function tryGetNameFromFileLike(data) {
+  if (isNamedValue(data)) {
+    return data.name;
+  }
+  if (isPathedValue(data)) {
+    return getNameFromPath(data.path.toString());
+  }
+  return void 0;
+}
+async function tryGetContentLengthFromFileLike(data, { noSniffFileSize } = {}) {
+  if (isBuffer(data)) {
+    return data.length;
+  }
+  if (isArrayBufferView(data)) {
+    return data.byteLength;
+  }
+  if (isArrayBuffer(data)) {
+    return data.byteLength;
+  }
+  if (isBlob(data)) {
+    return data.size;
+  }
+  if (isFile(data)) {
+    return data.size;
+  }
+  if (noSniffFileSize === true) {
+    return void 0;
+  }
+  if (isPathedValue(data)) {
+    return await tryGetFileSizeFromPath(data.path.toString());
+  }
+  return void 0;
+}
+function tryGetContentTypeFromFileLike(data) {
+  if (isBlob(data)) {
+    return data.type;
+  }
+  if (isFile(data)) {
+    return data.type;
+  }
+  return void 0;
+}
+function getNameFromPath(path) {
+  const lastForwardSlash = path.lastIndexOf("/");
+  const lastBackSlash = path.lastIndexOf("\\");
+  const lastSlashIndex = Math.max(lastForwardSlash, lastBackSlash);
+  return lastSlashIndex >= 0 ? path.substring(lastSlashIndex + 1) : path;
+}
+function isNamedValue(value) {
+  return typeof value === "object" && value != null && "name" in value;
+}
+function isPathedValue(value) {
+  return typeof value === "object" && value != null && "path" in value;
+}
+function isStreamLike(value) {
+  return typeof value === "object" && value != null && ("read" in value || "pipe" in value);
+}
+function isReadableStream(value) {
+  return typeof value === "object" && value != null && "getReader" in value;
+}
+function isBuffer(value) {
+  return typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(value);
+}
+function isArrayBufferView(value) {
+  return typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(value);
+}
+function isArrayBuffer(value) {
+  return typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer;
+}
+function isUint8Array(value) {
+  return typeof Uint8Array !== "undefined" && value instanceof Uint8Array;
+}
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFile(value) {
+  return typeof File !== "undefined" && value instanceof File;
+}
+
 // ../../packages/client/src/generated/core/logging/index.ts
 var logging_exports = {};
 __export(logging_exports, {
@@ -2072,6 +2249,116 @@ var HarnessFilesystemClient = class {
     }
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/harness/filesystem/glob");
   }
+  /**
+   * @param {CngApi.GetHarnessFilesystemLsRequest} request
+   * @param {HarnessFilesystemClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link CngApi.BadRequestError}
+   *
+   * @example
+   *     await client.harnessFilesystem.getHarnessFilesystemLs()
+   */
+  getHarnessFilesystemLs(request = {}, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getHarnessFilesystemLs(request, requestOptions));
+  }
+  async __getHarnessFilesystemLs(request = {}, requestOptions) {
+    const { path, limit } = request;
+    const _queryParams = {
+      path,
+      limit
+    };
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/filesystem/ls"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/harness/filesystem/ls");
+  }
+  /**
+   * @param {CngApi.GetHarnessFilesystemStatRequest} request
+   * @param {HarnessFilesystemClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link CngApi.BadRequestError}
+   * @throws {@link CngApi.NotFoundError}
+   *
+   * @example
+   *     await client.harnessFilesystem.getHarnessFilesystemStat({
+   *         path: "path"
+   *     })
+   */
+  getHarnessFilesystemStat(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getHarnessFilesystemStat(request, requestOptions));
+  }
+  async __getHarnessFilesystemStat(request, requestOptions) {
+    const { path } = request;
+    const _queryParams = {
+      path
+    };
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/filesystem/stat"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/harness/filesystem/stat");
+  }
 };
 
 // ../../packages/client/src/generated/api/resources/harnessInternalKnowledges/client/Client.ts
@@ -2870,6 +3157,63 @@ var HarnessKnowledgesClient = class {
   }
 };
 
+// ../../packages/client/src/generated/api/resources/hookify/client/Client.ts
+var HookifyClient = class {
+  _options;
+  constructor(options = {}) {
+    this._options = normalizeClientOptions(options);
+  }
+  /**
+   * @param {core.file.Uploadable} uploadable
+   * @param {CngApi.IngestHookifyHookRequest} request
+   * @param {HookifyClient.RequestOptions} requestOptions - Request-specific configuration.
+   */
+  ingestHookifyHook(uploadable, request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__ingestHookifyHook(uploadable, request, requestOptions));
+  }
+  async __ingestHookifyHook(uploadable, request, requestOptions) {
+    const _queryParams = {
+      mode: request.mode != null ? request.mode : void 0,
+      event: request.event
+    };
+    const _binaryUploadRequest = await file_exports.toBinaryUploadRequest(uploadable);
+    const _headers = mergeHeaders(
+      this._options?.headers,
+      _binaryUploadRequest.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/hookify/ingest"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/octet-stream",
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "bytes",
+      duplex: "half",
+      body: _binaryUploadRequest.body,
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      throw new CngApiError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body,
+        rawResponse: _response.rawResponse
+      });
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/api/hookify/ingest");
+  }
+};
+
 // ../../packages/client/src/generated/api/resources/llm/client/Client.ts
 var LlmClient = class {
   _options;
@@ -3142,6 +3486,7 @@ var CngApiClient = class {
   _polar;
   _telemetry;
   _llm;
+  _hookify;
   constructor(options = {}) {
     this._options = normalizeClientOptions(options);
   }
@@ -3169,6 +3514,9 @@ var CngApiClient = class {
   get llm() {
     return this._llm ??= new LlmClient(this._options);
   }
+  get hookify() {
+    return this._hookify ??= new HookifyClient(this._options);
+  }
   /**
    * Make a passthrough request using the SDK's configured auth, retry, logging, etc.
    * This is useful for making requests to endpoints not yet supported in the SDK.
@@ -3231,4 +3579,4 @@ export {
   createCngApiClient,
   readBackendHealth
 };
-//# sourceMappingURL=chunk-HRFI2IEP.js.map
+//# sourceMappingURL=chunk-FJ34NVQ4.js.map