@rtc-agent/component 0.2.9-rc.1 → 0.3.0-rc.1

package/dist/.generated/locales/en-US.d.ts

@@ -264,5 +264,20 @@ export declare const templates: {
     sfcf02d7fbb1eef49: string;
     sfd3a5046f19f54d0: string;
     sfea2ebf059badaef: string;
+    s473e939112690a50: string;
+    s9d1b66ae2017a0e5: string;
+    s19701948ff347238: string;
+    sac77b3a437c0f21d: string;
+    s2f015ae7a7bb3cec: string;
+    sf3bfb0839acc4bb7: import("@lit/localize").StrResult;
+    sf3090d705d4de077: import("@lit/localize").StrResult;
+    sa0903f2fc0126db5: string;
+    sf3349f071f2bab10: string;
+    s795fca7acd5146f2: string;
+    se03b0995736ec63d: string;
+    s631275c801a0881f: string;
+    s132a9d11517f52d1: string;
+    sea0723ac2f4955af: string;
+    s9a9759b2d054bbdc: string;
 };
 //# sourceMappingURL=en-US.d.ts.map

package/dist/.generated/locales/en-US.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"en-US.d.ts","sourceRoot":"","sources":["../../../src/.generated/locales/en-US.ts"],"names":[],"mappings":"AAUI,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0QrB,CAAC"}
+{"version":3,"file":"en-US.d.ts","sourceRoot":"","sources":["../../../src/.generated/locales/en-US.ts"],"names":[],"mappings":"AAUI,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyRrB,CAAC"}

package/dist/assets/index.browser-D4SG7v3Y.js

@@ -0,0 +1,201 @@
+var I = Object.defineProperty;
+var R = (E, e, s) => e in E ? I(E, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : E[e] = s;
+var w = (E, e, s) => R(E, typeof e != "symbol" ? e + "" : e, s);
+import { h as C, t as B, T as U, f as H, e as N } from "./shared-worker-Bw4_Rekb.js";
+import { E as D, a as $, H as F, I as K, M as L, b as q, S as G, c as J, d as Q, g as V, i as W, j as X, r as Y, k as Z } from "./shared-worker-Bw4_Rekb.js";
+class O {
+  constructor({ marshaller: e, serializer: s, deserializer: l, serdeContext: c, defaultContentType: d, compositeErrorRegistry: o }) {
+    w(this, "marshaller");
+    w(this, "serializer");
+    w(this, "deserializer");
+    w(this, "serdeContext");
+    w(this, "defaultContentType");
+    w(this, "compositeErrorRegistry");
+    this.marshaller = e, this.serializer = s, this.deserializer = l, this.serdeContext = c, this.defaultContentType = d, this.compositeErrorRegistry = o;
+  }
+  async serializeEventStream({ eventStream: e, requestSchema: s, initialRequest: l, initialMessageType: c }) {
+    const d = this.marshaller, o = s.getEventStreamMember(), f = s.getMemberSchema(o), S = this.serializer, y = this.defaultContentType, m = Symbol("initialRequestMarker"), u = {
+      async *[Symbol.asyncIterator]() {
+        if (l) {
+          const t = {
+            ":event-type": { type: "string", value: c ?? "initial-request" },
+            ":message-type": { type: "string", value: "event" },
+            ":content-type": { type: "string", value: y }
+          };
+          S.write(s, l);
+          const n = S.flush();
+          yield {
+            [m]: !0,
+            headers: t,
+            body: n
+          };
+        }
+        for await (const t of e)
+          yield t;
+      }
+    };
+    return d.serialize(u, (t) => {
+      if (t[m])
+        return {
+          headers: t.headers,
+          body: t.body
+        };
+      let n = "";
+      for (const a in t)
+        if (C(t, a) && a !== "__type") {
+          n = a;
+          break;
+        }
+      const { additionalHeaders: r, body: i, eventType: h, explicitPayloadContentType: M } = this.writeEventBody(n, f, t);
+      return {
+        headers: {
+          ":event-type": { type: "string", value: h },
+          ":message-type": { type: "string", value: "event" },
+          ":content-type": { type: "string", value: M ?? y },
+          ...r
+        },
+        body: i
+      };
+    });
+  }
+  async deserializeEventStream({ response: e, responseSchema: s, initialResponseContainer: l, initialMessageType: c }) {
+    var n;
+    const d = this.marshaller, o = s.getEventStreamMember(), S = s.getMemberSchema(o).getMemberSchemas(), y = Symbol("initialResponseMarker"), m = d.deserialize(e.body, async (r) => {
+      var M, g;
+      let i = "";
+      for (const a in r)
+        if (C(r, a) && a !== "__type") {
+          i = a;
+          break;
+        }
+      const h = r[i].body;
+      if (i === (c ?? "initial-response")) {
+        const a = await this.deserializer.read(s, h);
+        return delete a[o], {
+          [y]: !0,
+          ...a
+        };
+      } else if (i in S) {
+        const a = S[i];
+        if (a.isStructSchema()) {
+          const p = {};
+          let T = !1;
+          for (const [b, z] of a.structIterator()) {
+            const { eventHeader: k, eventPayload: x } = z.getMergedTraits();
+            if (T = T || !!(k || x), x)
+              z.isBlobSchema() ? p[b] = h : z.isStringSchema() ? p[b] = (((M = this.serdeContext) == null ? void 0 : M.utf8Encoder) ?? B)(h) : z.isStructSchema() && (p[b] = await this.deserializer.read(z, h));
+            else if (k) {
+              const v = (g = r[i].headers[b]) == null ? void 0 : g.value;
+              v != null && (z.isNumericSchema() ? v && typeof v == "object" && "bytes" in v ? p[b] = BigInt(v.toString()) : p[b] = Number(v) : p[b] = v);
+            }
+          }
+          return {
+            [i]: await this.readEventMember(a, h, T, p)
+          };
+        }
+        return {
+          [i]: await this.deserializer.read(a, h)
+        };
+      } else
+        return {
+          $unknown: r
+        };
+    }), u = m[Symbol.asyncIterator](), t = await u.next();
+    if (t.done)
+      return m;
+    if ((n = t.value) != null && n[y]) {
+      if (!s)
+        throw new Error("@smithy::core/protocols - initial-response event encountered in event stream but no response schema given.");
+      for (const r in t.value)
+        C(t.value, r) && (l[r] = t.value[r]);
+    }
+    return {
+      async *[Symbol.asyncIterator]() {
+        var r;
+        for ((r = t == null ? void 0 : t.value) != null && r[y] || (yield t.value); ; ) {
+          const { done: i, value: h } = await u.next();
+          if (i)
+            break;
+          yield h;
+        }
+      }
+    };
+  }
+  async readEventMember(e, s, l, c) {
+    var S, y;
+    let d;
+    const o = e.getSchema();
+    if (Array.isArray(o) && o[0] === -3) {
+      const m = o[1], u = U.for(m);
+      (S = this.compositeErrorRegistry) == null || S.copyFrom(u), d = (y = this.compositeErrorRegistry ?? u) == null ? void 0 : y.getErrorCtor(o);
+    }
+    const f = l ? c : s.byteLength === 0 ? {} : await this.deserializer.read(e, s);
+    if (d) {
+      const m = f.message ?? f.Message ?? "Unknown", u = {}, t = e.getMergedTraits().error;
+      return t && (u.$fault = t), Object.assign(new d({}), u, {
+        message: m
+      }, f);
+    }
+    return f;
+  }
+  writeEventBody(e, s, l) {
+    var t;
+    const c = this.serializer;
+    let d = e, o = null, f;
+    const S = s.getSchema()[4].includes(e), y = {};
+    if (S) {
+      const n = s.getMemberSchema(e);
+      if (n.isStructSchema()) {
+        for (const [r, i] of n.structIterator()) {
+          const { eventHeader: h, eventPayload: M } = i.getMergedTraits();
+          if (M)
+            o = r;
+          else if (h) {
+            const g = l[e][r];
+            let a = "binary";
+            i.isNumericSchema() ? (-2) ** 31 <= g && g <= 2 ** 31 - 1 ? a = "integer" : a = "long" : i.isTimestampSchema() ? a = "timestamp" : i.isStringSchema() ? a = "string" : i.isBooleanSchema() && (a = "boolean"), g != null && (y[r] = {
+              type: a,
+              value: g
+            }, delete l[e][r]);
+          }
+        }
+        if (o !== null) {
+          const r = n.getMemberSchema(o);
+          r.isBlobSchema() ? f = "application/octet-stream" : r.isStringSchema() && (f = "text/plain"), c.write(r, l[e][o]);
+        } else
+          c.write(n, l[e]);
+      } else if (n.isUnitSchema())
+        c.write(n, {});
+      else
+        throw new Error("@smithy/core/event-streams - non-struct member not supported in event stream union.");
+    } else {
+      const [n, r] = l[e];
+      d = n, c.write(15, r);
+    }
+    const m = c.flush() ?? new Uint8Array();
+    return {
+      body: typeof m == "string" ? (((t = this.serdeContext) == null ? void 0 : t.utf8Decoder) ?? H)(m) : m,
+      eventType: d,
+      explicitPayloadContentType: f,
+      additionalHeaders: y
+    };
+  }
+}
+export {
+  D as EventStreamCodec,
+  $ as EventStreamMarshaller,
+  O as EventStreamSerde,
+  F as HeaderMarshaller,
+  K as Int64,
+  L as MessageDecoderStream,
+  q as MessageEncoderStream,
+  G as SmithyMessageDecoderStream,
+  J as SmithyMessageEncoderStream,
+  Q as UniversalEventStreamMarshaller,
+  N as eventStreamSerdeProvider,
+  V as getChunkedStream,
+  W as getMessageUnmarshaller,
+  X as iterableToReadableStream,
+  Y as readableStreamToIterable,
+  Z as resolveEventStreamSerdeConfig
+};