npm - @superblocksteam/sdk-api - Versions diffs - 2.0.156-next.3 → 2.0.156 - Mend

@superblocksteam/sdk-api 2.0.156-next.3 → 2.0.156

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (57) hide show

package/src/integrations/mistral/README.md CHANGED Viewed

@@ -277,13 +277,6 @@ All methods accept an optional `metadata` parameter as the last argument for dia
 ## Common Pitfalls
-### Streaming Is Not Supported
-`apiRequest()` does not support streaming or Server-Sent Events. Do not set
-`stream: true` — streaming responses fail schema validation. Every call
-returns the complete response; if a UI needs real-time token streaming,
-handle it at the frontend layer, not through the SDK.
 ### No Specialized Methods
 ```typescript

package/src/integrations/openai_v2/README.md CHANGED Viewed

@@ -257,13 +257,6 @@ All methods accept an optional `metadata` parameter as the last argument for dia
 ## Common Pitfalls
-### Streaming Is Not Supported
-`apiRequest()` does not support streaming or Server-Sent Events. Do not set
-`stream: true` — streaming responses fail schema validation. Every call
-returns the complete response; if a UI needs real-time token streaming,
-handle it at the frontend layer, not through the SDK.
 ### No Specialized Methods
 The OpenAI client only provides `apiRequest()`. There are no other specialized methods:

package/src/integrations/perplexity/README.md CHANGED Viewed

@@ -189,13 +189,6 @@ All methods accept an optional `metadata` parameter as the last argument for dia
 ## Common Pitfalls
-### Streaming Is Not Supported
-`apiRequest()` does not support streaming or Server-Sent Events. Do not set
-`stream: true` — streaming responses fail schema validation. Every call
-returns the complete response; if a UI needs real-time token streaming,
-handle it at the frontend layer, not through the SDK.
 ### No Specialized Methods
 ```typescript

package/src/integrations/restapiintegration/client.test.ts CHANGED Viewed

@@ -1,13 +1,37 @@
-import { describe, expect, expectTypeOf, it, vi } from "vitest";
+/**
+ * Tests for RestApiIntegrationPluginClientImpl (generic REST API Integration).
+ *
+ * Covers the responseType passthrough:
+ * - default requests keep responseType "json"; callers that pass a
+ *   response schema still get validated results
+ * - the responseType option is forwarded to the orchestrator request
+ * - non-JSON responses (e.g. XML with responseType "text") are returned
+ *   raw when no response schema is provided
+ */
+import { describe, it, expect, vi } from "vitest";
 import { z } from "zod";
-import type { ActionResponseType } from "@superblocksteam/shared";
+import { ActionResponseType } from "@superblocksteam/shared";
 import { RestApiValidationError } from "../../errors.js";
-import { REST_API_RESPONSE_TYPES } from "../base/types.js";
+import type { RestApiResponseType } from "../base/types.js";
 import type { IntegrationConfig } from "../types.js";
 import { RestApiIntegrationPluginClientImpl } from "./client.js";
+// ── Wire-contract assertions (verified by `pnpm typecheck`) ────────
+//
+// The responseType strings are sent to the orchestrator as-is; the
+// accepted values are defined by ActionResponseType. This assertion
+// fails compilation if the SDK union drifts outside the wire values.
+//
+// The SDK union is a deliberate subset of the wire values: "auto" and
+// "binary" are implemented by the orchestrator but not exposed (see the
+// RestApiResponseType doc for why), and "raw" is streaming-only.
+const _sdkValuesAreValidWireValues: Exclude<`${ActionResponseType}`, "raw">[] =
+  [] as RestApiResponseType[];
+void _sdkValuesAreValidWireValues;
 const TEST_CONFIG: IntegrationConfig = {
   id: "restapi-test-id",
   name: "Test REST API",
@@ -16,11 +40,6 @@ const TEST_CONFIG: IntegrationConfig = {
 };
 const XML_RESPONSE = `<?xml version="1.0"?><note><body>hi</body></note>`;
-const PDF_BYTES = [0x25, 0x50, 0x44, 0x46];
-function workerBufferPayload(data: unknown): unknown {
-  return { type: "Buffer", data };
-}
 function createClient(mockResult: unknown) {
   const executeQuery = vi.fn().mockResolvedValue(mockResult);
@@ -31,14 +50,9 @@ function createClient(mockResult: unknown) {
   return { client, executeQuery };
 }
-function callApiRequest(
-  client: RestApiIntegrationPluginClientImpl,
-  ...args: unknown[]
-): Promise<unknown> {
-  return Reflect.apply(client.apiRequest, client, args);
-}
 describe("RestApiIntegrationPluginClientImpl", () => {
+  // ── Default JSON behavior (must not regress) ────────────────────
   describe("default JSON behavior", () => {
     it("sends responseType json when the option is omitted", async () => {
       const { client, executeQuery } = createClient({ id: "1" });
@@ -67,26 +81,19 @@ describe("RestApiIntegrationPluginClientImpl", () => {
     });
     it("throws RestApiValidationError when the response does not match the schema", async () => {
-      const payload = XML_RESPONSE;
-      const { client } = createClient(payload);
+      const { client } = createClient(XML_RESPONSE);
-      try {
-        await client.apiRequest(
+      await expect(
+        client.apiRequest(
           { method: "GET", path: "/users" },
           { response: z.object({ id: z.string() }) },
-        );
-      } catch (error) {
-        expect(error).toBeInstanceOf(RestApiValidationError);
-        if (!(error instanceof RestApiValidationError)) {
-          throw error;
-        }
-        expect(error.details.data).toBe(payload);
-        return;
-      }
-      throw new Error("Expected JSON response validation to fail");
+        ),
+      ).rejects.toThrow(RestApiValidationError);
     });
   });
+  // ── responseType passthrough ────────────────────────────────────
   describe("responseType passthrough", () => {
     it("forwards responseType text to the orchestrator request", async () => {
       const { client, executeQuery } = createClient(XML_RESPONSE);
@@ -145,6 +152,8 @@ describe("RestApiIntegrationPluginClientImpl", () => {
     });
     it("returns an empty string unchanged for responseType text", async () => {
+      // An empty text body legitimately decodes to "" — the null/undefined
+      // guard must not reject it.
       const { client } = createClient("");
       const result = await client.apiRequest({
@@ -157,6 +166,10 @@ describe("RestApiIntegrationPluginClientImpl", () => {
     });
     it("rejects null and undefined results for every response type", async () => {
+      // Neither value is a legitimate decode result for the exposed
+      // response types: JSON parses to a value the schema sees, and an
+      // empty text body decodes to "". Either means a broken execution
+      // contract, so both throw.
       for (const badResult of [null, undefined]) {
         const { client: textClient } = createClient(badResult);
         await expect(
@@ -167,15 +180,8 @@ describe("RestApiIntegrationPluginClientImpl", () => {
           }),
         ).rejects.toThrow(RestApiValidationError);
-        const { client: binaryClient } = createClient(badResult);
-        await expect(
-          binaryClient.apiRequest({
-            method: "GET",
-            path: "/broken",
-            responseType: "binary",
-          }),
-        ).rejects.toThrow(RestApiValidationError);
+        // JSON mode always goes through the schema overload; the bad
+        // result is rejected before validation runs.
         const { client: jsonClient } = createClient(badResult);
         await expect(
           jsonClient.apiRequest(
@@ -187,109 +193,14 @@ describe("RestApiIntegrationPluginClientImpl", () => {
     });
   });
-  describe("responseType binary", () => {
-    it("forwards responseType binary and returns decoded bytes", async () => {
-      const { client, executeQuery } = createClient(
-        workerBufferPayload(PDF_BYTES),
-      );
-      const result = await client.apiRequest({
-        method: "GET",
-        path: "/file.pdf",
-        responseType: "binary",
-      });
-      expect(executeQuery).toHaveBeenCalledWith(
-        expect.objectContaining({ responseType: "binary" }),
-        undefined,
-        undefined,
-      );
-      expect(result).toBeInstanceOf(Uint8Array);
-      expect(result.constructor).toBe(Uint8Array);
-      expect(Array.from(result)).toEqual(PDF_BYTES);
-    });
-    it("rejects malformed binary data before applying a response schema", async () => {
-      const malformed = workerBufferPayload([256]);
-      const { client, executeQuery } = createClient(malformed);
-      const workerShapeSchema = z.object({
-        type: z.literal("Buffer"),
-        data: z.array(z.number()),
-      });
-      await expect(
-        callApiRequest(
-          client,
-          { method: "GET", path: "/file.pdf", responseType: "binary" },
-          { response: workerShapeSchema },
-        ),
-      ).rejects.toThrow(RestApiValidationError);
-      expect(executeQuery).toHaveBeenCalled();
-    });
-    it("accepts response schemas that transform bytes to bytes", async () => {
-      const { client } = createClient(workerBufferPayload(PDF_BYTES));
-      const result = await client.apiRequest(
-        { method: "GET", path: "/file.pdf", responseType: "binary" },
-        {
-          response: z
-            .instanceof(Uint8Array)
-            .refine((bytes) => bytes[0] === 0x25)
-            .transform((bytes) => bytes.slice(1)),
-        },
-      );
-      expect(Array.from(result)).toEqual(PDF_BYTES.slice(1));
-    });
-    it("throws RestApiValidationError when the schema rejects normalized bytes", async () => {
-      const { client } = createClient(workerBufferPayload(PDF_BYTES));
-      await expect(
-        client.apiRequest(
-          { method: "GET", path: "/file.pdf", responseType: "binary" },
-          {
-            response: z
-              .instanceof(Uint8Array)
-              .refine((bytes) => bytes.byteLength > 64),
-          },
-        ),
-      ).rejects.toThrow(RestApiValidationError);
-    });
-    it("redacts binary data from response validation errors", async () => {
-      const bytes = Array.from({ length: 4096 }, () => 0);
-      const { client } = createClient(workerBufferPayload(bytes));
-      try {
-        await client.apiRequest(
-          { method: "GET", path: "/file.pdf", responseType: "binary" },
-          {
-            response: z
-              .instanceof(Uint8Array)
-              .refine((value) => value.byteLength < 1024),
-          },
-        );
-      } catch (error) {
-        expect(error).toBeInstanceOf(RestApiValidationError);
-        if (!(error instanceof RestApiValidationError)) {
-          throw error;
-        }
-        expect(error.details.data).toEqual({
-          dataType: "binary",
-          redacted: true,
-        });
-        return;
-      }
-      throw new Error("Expected binary response validation to fail");
-    });
-  });
+  // ── Request-body validation via the schema-less overload ────────
   describe("request body validation", () => {
     it("throws RestApiValidationError for an invalid body with a body-only schema", async () => {
       const { client, executeQuery } = createClient({ ok: true });
+      // Runtime-invalid bodies reach this path via dynamic data (user
+      // input, parsed JSON) that the compiler cannot check.
       const dynamicBody: unknown = JSON.parse('{"amount":"not-a-number"}');
       await expect(
@@ -331,12 +242,23 @@ describe("RestApiIntegrationPluginClientImpl", () => {
     });
   });
+  // ── Runtime contract enforcement ─────────────────────────────────
+  //
+  // The overloads make these calls unrepresentable in TypeScript, but
+  // user API code executes as esbuild-bundled JS with no type
+  // enforcement — the same contract must hold at runtime.
   describe("runtime contract enforcement", () => {
+    type UncheckedApiRequest = (...args: unknown[]) => Promise<unknown>;
     it("rejects a schema-less call in default JSON mode without issuing the request", async () => {
       const { client, executeQuery } = createClient({ ok: true });
       await expect(
-        callApiRequest(client, { method: "GET", path: "/users" }),
+        (client.apiRequest as UncheckedApiRequest)({
+          method: "GET",
+          path: "/users",
+        }),
       ).rejects.toThrow(RestApiValidationError);
       expect(executeQuery).not.toHaveBeenCalled();
     });
@@ -345,8 +267,7 @@ describe("RestApiIntegrationPluginClientImpl", () => {
       const { client, executeQuery } = createClient({ ok: true });
       await expect(
-        callApiRequest(
-          client,
+        (client.apiRequest as UncheckedApiRequest)(
           {
             method: "POST",
             path: "/orders",
@@ -359,32 +280,27 @@ describe("RestApiIntegrationPluginClientImpl", () => {
       expect(executeQuery).not.toHaveBeenCalled();
     });
-    it("rejects auto, which can yield unvalidated JSON, and raw, which is streaming-only", async () => {
-      for (const responseType of ["auto", "raw"]) {
-        const { client, executeQuery } = createClient({ ok: true });
+    it("rejects an unexposed responseType value without issuing the request", async () => {
+      const { client, executeQuery } = createClient({ ok: true });
-        await expect(
-          callApiRequest(client, {
-            method: "GET",
-            path: "/report",
-            responseType,
-          }),
-        ).rejects.toThrow(RestApiValidationError);
-        expect(executeQuery).not.toHaveBeenCalled();
-      }
+      await expect(
+        (client.apiRequest as UncheckedApiRequest)({
+          method: "GET",
+          path: "/report",
+          responseType: "auto",
+        }),
+      ).rejects.toThrow(RestApiValidationError);
+      expect(executeQuery).not.toHaveBeenCalled();
     });
   });
-  describe("overload resolution", () => {
-    it("keeps public response types within the worker contract", () => {
-      expectTypeOf<(typeof REST_API_RESPONSE_TYPES)[number]>().toMatchTypeOf<
-        Exclude<`${ActionResponseType}`, "raw">
-      >();
-    });
+  // ── Compile-time overload contracts (verified by `pnpm typecheck`) ──
+  describe("overload resolution", () => {
     it("keeps typed results for schema callers and unknown for schema-less calls", async () => {
       const { client } = createClient({ id: "1" });
+      // With a response schema: resolves to the typed overload.
       const typed: Promise<{ id: string }> = client.apiRequest(
         { method: "GET", path: "/users" },
         { response: z.object({ id: z.string() }) },
@@ -393,6 +309,7 @@ describe("RestApiIntegrationPluginClientImpl", () => {
       const { client: rawClient } = createClient(XML_RESPONSE);
+      // Without a schema: resolves to the raw overload returning unknown.
       const raw: Promise<unknown> = rawClient.apiRequest({
         method: "GET",
         path: "/report.xml",
@@ -408,58 +325,20 @@ describe("RestApiIntegrationPluginClientImpl", () => {
       });
       await wrong;
-      // @ts-expect-error unvalidated JSON is unrepresentable; schema-less calls must opt into a non-JSON responseType
+      // The remaining cases are rejected twice over: at compile time by
+      // the overloads (@ts-expect-error) and at runtime by the contract
+      // guards, since bundled user code carries no types.
+      // @ts-expect-error unvalidated JSON is unrepresentable — schema-less
+      // calls must opt into a non-JSON responseType
       const unvalidatedJson = rawClient.apiRequest({
         method: "GET",
         path: "/users",
       });
       await expect(unvalidatedJson).rejects.toThrow(RestApiValidationError);
-    });
-    it("types schema-less binary responses as Uint8Array", async () => {
-      const { client: binaryClient } = createClient(
-        workerBufferPayload(PDF_BYTES),
-      );
-      const binary: Promise<Uint8Array> = binaryClient.apiRequest({
-        method: "GET",
-        path: "/file.pdf",
-        responseType: "binary",
-      });
-      expectTypeOf(binary).toEqualTypeOf<Promise<Uint8Array>>();
-      expect(Array.from(await binary)).toEqual(PDF_BYTES);
-      // @ts-expect-error schema-less binary apiRequest returns Uint8Array
-      const wrongBinary: Promise<string> = binaryClient.apiRequest({
-        method: "GET",
-        path: "/file.pdf",
-        responseType: "binary",
-      });
-      await wrongBinary;
-    });
-    it("rejects binary response schemas that transform bytes to another type", () => {
-      const { client: binaryClient } = createClient(
-        workerBufferPayload(PDF_BYTES),
-      );
-      // @ts-expect-error binary response schemas must output Uint8Array
-      binaryClient.apiRequest(
-        {
-          method: "GET",
-          path: "/file.pdf",
-          responseType: "binary",
-        },
-        {
-          response: z
-            .instanceof(Uint8Array)
-            .transform((bytes) => bytes.byteLength),
-        },
-      );
-    });
-    it("rejects response types outside the public SDK contract", async () => {
-      const { client: rawClient } = createClient(XML_RESPONSE);
+      // "auto" and "binary" are valid wire values but deliberately not
+      // exposed in the SDK union (see RestApiResponseType).
       const autoCall = rawClient.apiRequest({
         method: "GET",
         path: "/report.xml",
@@ -468,13 +347,13 @@ describe("RestApiIntegrationPluginClientImpl", () => {
       });
       await expect(autoCall).rejects.toThrow(RestApiValidationError);
-      const rawCall = rawClient.apiRequest({
+      const binaryCall = rawClient.apiRequest({
         method: "GET",
         path: "/report.xml",
-        // @ts-expect-error "raw" is not an exposed responseType
-        responseType: "raw",
+        // @ts-expect-error "binary" is not an exposed responseType
+        responseType: "binary",
       });
-      await expect(rawCall).rejects.toThrow(RestApiValidationError);
+      await expect(binaryCall).rejects.toThrow(RestApiValidationError);
     });
   });
 });

package/src/integrations/restapiintegration/docs.manifest.json CHANGED Viewed

@@ -4,11 +4,7 @@
   "overlays": [
     {
       "file": "overlays/response-types.md",
-      "sdkVersionRange": ">=0.0.3 <0.0.4"
-    },
-    {
-      "file": "overlays/response-types-binary.md",
-      "sdkVersionRange": ">=0.0.4"
+      "sdkVersionRange": ">=0.0.3"
     },
     {
       "file": "overlays/response-types-unsupported.md",

package/src/integrations/s3/README.md CHANGED Viewed

@@ -25,7 +25,6 @@ import { api, z, s3 } from "@superblocksteam/sdk-api";
 const PROD_S3 = "a1b2c3d4-5678-90ab-cdef-s300000001";
 export default api({
-  name: "ListBucketObjects",
   integrations: {
     storage: s3(PROD_S3),
   },

package/src/integrations/slack/client.test.ts CHANGED Viewed

@@ -12,7 +12,6 @@ import { describe, it, expect, vi } from "vitest";
 import { z } from "zod";
 import { RestApiValidationError } from "../../errors.js";
-import { REDACTED_BINARY_RESPONSE_DATA } from "../base/decode-worker-binary-response.js";
 import type { IntegrationConfig } from "../types.js";
 import { SlackClientImpl } from "./client.js";
 import type { SlackErrorResponse } from "./types.js";
@@ -509,41 +508,7 @@ describe("SlackClientImpl", () => {
     });
   });
-  describe("responseType binary", () => {
-    const pdfBytes = [0x25, 0x50, 0x44, 0x46];
-    const workerPayload = { type: "Buffer", data: pdfBytes };
-    it("decodes worker Buffer JSON and redacts it from validation errors", async () => {
-      const { client, executeQuery } = createClient(workerPayload);
-      try {
-        await client.apiRequest(
-          {
-            method: "GET",
-            path: "/files.download",
-            responseType: "binary",
-          },
-          { response: ChannelsSchema },
-        );
-      } catch (error) {
-        expect(error).toBeInstanceOf(RestApiValidationError);
-        if (!(error instanceof RestApiValidationError)) {
-          throw error;
-        }
-        expect(executeQuery).toHaveBeenCalledWith(
-          expect.objectContaining({ responseType: "binary" }),
-          undefined,
-          undefined,
-        );
-        expect(error.details.data).toEqual(REDACTED_BINARY_RESPONSE_DATA);
-        expect(error.details.data).not.toEqual(workerPayload);
-        return;
-      }
-      throw new Error(
-        "Expected Slack binary apiRequest to fail envelope validation",
-      );
-    });
-  });
+  // ── Type narrowing (compile-time verification) ─────────────────
   describe("type narrowing", () => {
     it("narrows to error response fields when ok is false", async () => {

package/src/integrations/snowflakecortex/README.md CHANGED Viewed

@@ -108,14 +108,6 @@ All methods accept an optional `metadata` parameter as the last argument for dia
 ## Common Pitfalls
-### Streaming Is Not Supported
-`apiRequest()` does not support streaming or Server-Sent Events. Always set
-`stream: false` in Cortex request bodies (as the examples do) — a streaming
-response fails schema validation. Every call returns the complete response;
-if a UI needs real-time token streaming, handle it at the frontend layer,
-not through the SDK.
 ### No Specialized Methods
 The Snowflake Cortex client only provides `apiRequest()`. There are no other specialized methods:

package/src/integrations/stabilityai/README.md CHANGED Viewed

@@ -234,13 +234,6 @@ All methods accept an optional `metadata` parameter as the last argument for dia
 ## Common Pitfalls
-### Streaming Is Not Supported
-`apiRequest()` does not support streaming or Server-Sent Events. Do not set
-`stream: true` — streaming responses fail schema validation. Every call
-returns the complete response; if a UI needs real-time token streaming,
-handle it at the frontend layer, not through the SDK.
 ### No Specialized Methods
 ```typescript

package/dist/integrations/base/decode-worker-binary-response.d.ts DELETED Viewed

@@ -1,4 +0,0 @@
-import { REDACTED_BINARY_RESPONSE_DATA } from "../../errors.js";
-export { REDACTED_BINARY_RESPONSE_DATA };
-export declare function decodeWorkerBinaryResponse(value: unknown): Uint8Array;
-//# sourceMappingURL=decode-worker-binary-response.d.ts.map

package/dist/integrations/base/decode-worker-binary-response.d.ts.map DELETED Viewed

	@@ -1 +0,0 @@
1	- {"version":3,"file":"decode-worker-binary-response.d.ts","sourceRoot":"","sources":["../../../src/integrations/base/decode-worker-binary-response.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,6BAA6B,EAE9B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,6BAA6B,EAAE,CAAC;AA0CzC,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,CAYrE"}

package/dist/integrations/base/decode-worker-binary-response.js DELETED Viewed

@@ -1,49 +0,0 @@
-import { z } from "zod";
-import { REDACTED_BINARY_RESPONSE_DATA, RestApiValidationError, } from "../../errors.js";
-export { REDACTED_BINARY_RESPONSE_DATA };
-const workerBinaryResponseSchema = z.union([
-    z.instanceof(Uint8Array).transform((value) => new Uint8Array(value)),
-    z
-        .object({
-        data: z.unknown(),
-        type: z.literal("Buffer"),
-    })
-        .transform((value, context) => {
-        if (!Array.isArray(value.data)) {
-            context.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: "data must be an array of bytes",
-                path: ["data"],
-            });
-            return z.NEVER;
-        }
-        const bytes = new Uint8Array(value.data.length);
-        for (let index = 0; index < value.data.length; index += 1) {
-            const item = value.data[index];
-            if (typeof item !== "number" ||
-                !Number.isInteger(item) ||
-                item < 0 ||
-                item > 255) {
-                context.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    message: "byte must be an integer from 0 through 255",
-                    path: ["data", index],
-                });
-                return z.NEVER;
-            }
-            bytes[index] = item;
-        }
-        return bytes;
-    }),
-]);
-export function decodeWorkerBinaryResponse(value) {
-    const result = workerBinaryResponseSchema.safeParse(value);
-    if (!result.success) {
-        throw new RestApiValidationError(`Binary response is malformed: ${result.error.message}`, {
-            data: REDACTED_BINARY_RESPONSE_DATA,
-            zodError: result.error,
-        });
-    }
-    return result.data;
-}
-//# sourceMappingURL=decode-worker-binary-response.js.map

package/dist/integrations/base/decode-worker-binary-response.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"decode-worker-binary-response.js","sourceRoot":"","sources":["../../../src/integrations/base/decode-worker-binary-response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EACL,6BAA6B,EAC7B,sBAAsB,GACvB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,6BAA6B,EAAE,CAAC;AAEzC,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC;IACzC,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC;IACpE,CAAC;SACE,MAAM,CAAC;QACN,IAAI,EAAE,CAAC,CAAC,OAAO,EAAE;QACjB,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;KAC1B,CAAC;SACD,SAAS,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;QAC5B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YAC/B,OAAO,CAAC,QAAQ,CAAC;gBACf,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,MAAM;gBAC3B,OAAO,EAAE,gCAAgC;gBACzC,IAAI,EAAE,CAAC,MAAM,CAAC;aACf,CAAC,CAAC;YACH,OAAO,CAAC,CAAC,KAAK,CAAC;QACjB,CAAC;QAED,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAChD,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;YAC1D,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC/B,IACE,OAAO,IAAI,KAAK,QAAQ;gBACxB,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC;gBACvB,IAAI,GAAG,CAAC;gBACR,IAAI,GAAG,GAAG,EACV,CAAC;gBACD,OAAO,CAAC,QAAQ,CAAC;oBACf,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,MAAM;oBAC3B,OAAO,EAAE,4CAA4C;oBACrD,IAAI,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC;iBACtB,CAAC,CAAC;gBACH,OAAO,CAAC,CAAC,KAAK,CAAC;YACjB,CAAC;YACD,KAAK,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;QACtB,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;CACL,CAAC,CAAC;AAEH,MAAM,UAAU,0BAA0B,CAAC,KAAc;IACvD,MAAM,MAAM,GAAG,0BAA0B,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAC3D,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACpB,MAAM,IAAI,sBAAsB,CAC9B,iCAAiC,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,EACvD;YACE,IAAI,EAAE,6BAA6B;YACnC,QAAQ,EAAE,MAAM,CAAC,KAAK;SACvB,CACF,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC,IAAI,CAAC;AACrB,CAAC"}

package/dist/integrations/base/decode-worker-binary-response.test.d.ts DELETED Viewed

	@@ -1,2 +0,0 @@
1	- export {};
2	- //# sourceMappingURL=decode-worker-binary-response.test.d.ts.map

package/dist/integrations/base/decode-worker-binary-response.test.d.ts.map DELETED Viewed

	@@ -1 +0,0 @@
1	- {"version":3,"file":"decode-worker-binary-response.test.d.ts","sourceRoot":"","sources":["../../../src/integrations/base/decode-worker-binary-response.test.ts"],"names":[],"mappings":""}