@smplkit/sdk 3.0.51 → 3.0.53

package/dist/index.js

@@ -17097,10 +17097,10 @@ function resolveChain(chain, environment) {
 
 // src/config/types.ts
 var ItemType = /* @__PURE__ */ ((ItemType2) => {
-  ItemType2["STRING"] = "STRING";
-  ItemType2["NUMBER"] = "NUMBER";
   ItemType2["BOOLEAN"] = "BOOLEAN";
   ItemType2["JSON"] = "JSON";
+  ItemType2["NUMBER"] = "NUMBER";
+  ItemType2["STRING"] = "STRING";
   return ItemType2;
 })(ItemType || {});
 var ConfigItem = class {
@@ -18279,8 +18279,8 @@ import createClient3 from "openapi-fetch";
 
 // src/management/types.ts
 var EnvironmentClassification = /* @__PURE__ */ ((EnvironmentClassification3) => {
-  EnvironmentClassification3["STANDARD"] = "STANDARD";
   EnvironmentClassification3["AD_HOC"] = "AD_HOC";
+  EnvironmentClassification3["STANDARD"] = "STANDARD";
   return EnvironmentClassification3;
 })(EnvironmentClassification || {});
 var HEX_RE = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
@@ -18512,14 +18512,14 @@ var AccountSettings = class {
 
 // src/flags/types.ts
 var Op = /* @__PURE__ */ ((Op2) => {
+  Op2["CONTAINS"] = "contains";
   Op2["EQ"] = "==";
-  Op2["NEQ"] = "!=";
-  Op2["LT"] = "<";
-  Op2["LTE"] = "<=";
   Op2["GT"] = ">";
   Op2["GTE"] = ">=";
   Op2["IN"] = "in";
-  Op2["CONTAINS"] = "contains";
+  Op2["LT"] = "<";
+  Op2["LTE"] = "<=";
+  Op2["NEQ"] = "!=";
   return Op2;
 })(Op || {});
 var CONTEXT_FIELDS = /* @__PURE__ */ new Set([
@@ -19208,13 +19208,13 @@ function _coerceValues(values) {
 
 // src/logging/types.ts
 var LogLevel = /* @__PURE__ */ ((LogLevel5) => {
-  LogLevel5["TRACE"] = "TRACE";
   LogLevel5["DEBUG"] = "DEBUG";
-  LogLevel5["INFO"] = "INFO";
-  LogLevel5["WARN"] = "WARN";
   LogLevel5["ERROR"] = "ERROR";
   LogLevel5["FATAL"] = "FATAL";
+  LogLevel5["INFO"] = "INFO";
   LogLevel5["SILENT"] = "SILENT";
+  LogLevel5["TRACE"] = "TRACE";
+  LogLevel5["WARN"] = "WARN";
   return LogLevel5;
 })(LogLevel || {});
 var LoggerChangeEvent = class {
@@ -19840,6 +19840,137 @@ var LogGroupsClient = class {
   }
 };
 
+// src/audit/types.ts
+var HttpConfiguration = class {
+  /** HTTP verb used for delivery. Defaults to {@link HttpMethod.POST}. */
+  method;
+  /** Destination URL the audit service POSTs each event to. */
+  url;
+  /**
+   * Headers attached to every outbound request. Values carry credentials
+   * and are encrypted at rest server-side; reads return them redacted.
+   */
+  headers;
+  /**
+   * Status the destination must return for delivery to count as success
+   * — either an exact code (`"200"`, `"204"`) or a status class
+   * (`"2xx"`, `"4xx"`). Defaults to `"2xx"`.
+   */
+  successStatus;
+  constructor(fields = {}) {
+    this.method = fields.method ?? "POST" /* POST */;
+    this.url = fields.url ?? "";
+    this.headers = fields.headers ?? [];
+    this.successStatus = fields.successStatus ?? "2xx";
+  }
+};
+var Forwarder = class {
+  /**
+   * Server-assigned UUID for this forwarder. `null` until {@link save}
+   * has run for the first time.
+   */
+  id;
+  /** Display name. Free-form. */
+  name;
+  /** Destination type — see {@link ForwarderType}. */
+  forwarderType;
+  /** Destination request configuration. */
+  configuration;
+  /**
+   * When `false`, the audit service skips delivery for this forwarder
+   * but still records `filtered_out` deliveries.
+   */
+  enabled;
+  /** Optional free-text description. */
+  description;
+  /**
+   * Optional JSON Logic expression evaluated per event. When set, events
+   * that don't match are recorded as `filtered_out` deliveries instead
+   * of being POSTed to the destination.
+   */
+  filter;
+  /**
+   * Optional template applied to each event before delivery. Shape
+   * depends on {@link transformType}; for `"JSONATA"`, a JSONata
+   * expression string. `null` delivers the event JSON as-is.
+   */
+  transform;
+  /**
+   * Engine used to evaluate {@link transform}. Currently only
+   * `"JSONATA"` is supported. Auto-filled by the SDK whenever
+   * {@link transform} is set on save.
+   */
+  transformType;
+  /**
+   * When the audit service first persisted this forwarder. `null` for
+   * an unsaved instance.
+   */
+  createdAt;
+  /** When this forwarder was last mutated. */
+  updatedAt;
+  /** Soft-delete timestamp. `null` for live forwarders. */
+  deletedAt;
+  /** Monotonic version counter; bumped on every server-side write. */
+  version;
+  /** @internal */
+  _client;
+  constructor(client, fields) {
+    this._client = client;
+    this.id = fields.id ?? null;
+    this.name = fields.name;
+    this.forwarderType = fields.forwarderType;
+    this.configuration = fields.configuration;
+    this.enabled = fields.enabled ?? true;
+    this.description = fields.description ?? null;
+    this.filter = fields.filter ?? null;
+    this.transform = fields.transform ?? null;
+    this.transformType = fields.transformType ?? null;
+    this.createdAt = fields.createdAt ?? null;
+    this.updatedAt = fields.updatedAt ?? null;
+    this.deletedAt = fields.deletedAt ?? null;
+    this.version = fields.version ?? null;
+  }
+  /**
+   * Create or update this forwarder on the server.
+   *
+   * Upsert behavior is driven by {@link createdAt}: a forwarder with
+   * no `createdAt` is created (POST); otherwise it's full-replace
+   * updated (PUT). After the call, every field is refreshed from the
+   * server response (including newly-assigned `id`, `createdAt`,
+   * `updatedAt`, `version`).
+   */
+  async save() {
+    if (this._client === null) {
+      throw new Error("Forwarder was constructed without a client; cannot save");
+    }
+    const other = this.createdAt === null ? await this._client._createForwarder(this) : await this._client._updateForwarder(this);
+    this._apply(other);
+  }
+  /** Soft-delete this forwarder on the server. */
+  async delete() {
+    if (this._client === null || this.id === null) {
+      throw new Error("Forwarder was constructed without a client or id; cannot delete");
+    }
+    await this._client._deleteForwarder(this.id);
+  }
+  /** @internal Copy every server-authoritative field from `other` onto self. */
+  _apply(other) {
+    this.id = other.id;
+    this.name = other.name;
+    this.forwarderType = other.forwarderType;
+    this.configuration = other.configuration;
+    this.enabled = other.enabled;
+    this.description = other.description;
+    this.filter = other.filter;
+    this.transform = other.transform;
+    this.transformType = other.transformType;
+    this.createdAt = other.createdAt;
+    this.updatedAt = other.updatedAt;
+    this.deletedAt = other.deletedAt;
+    this.version = other.version;
+  }
+};
+
 // src/management/audit.ts
 async function checkError4(response) {
   const body = await response.text().catch(() => "");
@@ -19866,79 +19997,106 @@ function _paginationFromBody2(body) {
   }
   return out;
 }
-function _httpToWire(http) {
+function _configurationToWire(config) {
   return {
-    method: http.method,
-    url: http.url,
-    headers: http.headers.map((h) => ({ name: h.name, value: h.value })),
-    body: http.body,
-    success_status: http.successStatus
+    method: config.method,
+    url: config.url,
+    headers: config.headers.map((h) => ({ name: h.name, value: h.value })),
+    success_status: config.successStatus
   };
 }
-function _httpFromWire(raw) {
+function _configurationFromWire(raw) {
   const r = raw ?? {};
   const headers = (r.headers ?? []).map((h) => ({
     name: String(h.name ?? ""),
     value: String(h.value ?? "")
   }));
-  return {
-    method: String(r.method ?? "POST"),
+  return new HttpConfiguration({
+    method: r.method ?? "POST" /* POST */,
     url: String(r.url ?? ""),
     headers,
-    body: r.body ?? null,
     successStatus: String(r.success_status ?? "2xx")
-  };
+  });
 }
-function _forwarderAttributes(input) {
+function _forwarderAttrs(forwarder) {
   const attrs = {
-    name: input.name,
-    forwarder_type: input.forwarderType,
-    enabled: input.enabled ?? true,
-    http: _httpToWire(input.http)
+    name: forwarder.name,
+    forwarder_type: forwarder.forwarderType,
+    enabled: forwarder.enabled,
+    configuration: _configurationToWire(forwarder.configuration)
   };
-  if (input.filter !== void 0) {
-    attrs.filter = input.filter;
+  if (forwarder.description !== null) attrs.description = forwarder.description;
+  if (forwarder.filter !== null) {
+    attrs.filter = forwarder.filter;
+  }
+  if (forwarder.transform !== null) {
+    attrs.transform_type = "JSONATA" /* JSONATA */;
+    attrs.transform = forwarder.transform;
   }
-  if (input.transform !== void 0) attrs.transform = input.transform;
   return attrs;
 }
-function _forwarderFromResource(resource) {
+function _forwarderFromResource(resource, client) {
   const a = resource.attributes;
-  return {
+  return new Forwarder(client, {
     id: resource.id,
     name: String(a.name ?? ""),
-    slug: String(a.slug ?? ""),
+    description: a.description ?? null,
     forwarderType: a.forwarder_type,
     enabled: Boolean(a.enabled ?? true),
     filter: a.filter ?? null,
+    transformType: a.transform_type ?? null,
     transform: a.transform ?? null,
-    http: _httpFromWire(a.http),
+    configuration: _configurationFromWire(a.configuration),
     createdAt: a.created_at ?? null,
     updatedAt: a.updated_at ?? null,
     deletedAt: a.deleted_at ?? null,
     version: a.version ?? null
-  };
+  });
 }
 var ForwardersClient = class {
   /** @internal */
   constructor(_http) {
     this._http = _http;
   }
-  async create(input) {
-    const body = {
-      data: { id: "", type: "forwarder", attributes: _forwarderAttributes(input) }
-    };
-    let data;
-    try {
-      const result = await this._http.POST("/api/v1/forwarders", { body });
-      if (!result.response.ok) await checkError4(result.response);
-      data = result.data;
-    } catch (err) {
-      wrapFetchError4(err);
-    }
-    if (!data?.data) throw new SmplError("Unexpected empty response from audit");
-    return _forwarderFromResource(data.data);
+  /**
+   * Construct an unsaved {@link Forwarder}. Call {@link Forwarder.save}
+   * to persist.
+   *
+   * @param fields.name           Display name. Free-form.
+   * @param fields.forwarderType  Destination type — see {@link ForwarderType}.
+   * @param fields.configuration  Destination HTTP request configuration.
+   *                              Headers carry credentials and are
+   *                              encrypted at rest server-side; reads
+   *                              return them redacted.
+   * @param fields.enabled        Whether the forwarder is active. Defaults true.
+   * @param fields.description    Optional free-text description.
+   * @param fields.filter         Optional JSON Logic filter; events that
+   *                              don't match are recorded as
+   *                              `filtered_out` deliveries.
+   * @param fields.transform      Optional JSONata template applied to
+   *                              the event payload before POST. `null`
+   *                              delivers the event as-is.
+   */
+  new(fields) {
+    return new Forwarder(this, {
+      name: fields.name,
+      forwarderType: fields.forwarderType,
+      configuration: fields.configuration,
+      enabled: fields.enabled,
+      description: fields.description,
+      filter: fields.filter,
+      transform: fields.transform
+    });
   }
+  /**
+   * List forwarders for the authenticated account.
+   *
+   * Offset paginated per ADR-014: pass {@link ListForwardersParams.pageNumber}
+   * (1-based) and {@link ListForwardersParams.pageSize} (default 1000,
+   * max 1000). Pass `metaTotal=true` to populate `total` and `totalPages`
+   * in the returned `pagination` (costs an extra `COUNT` query
+   * server-side).
+   */
   async list(params = {}) {
     const query = {};
     if (params.forwarderType !== void 0) query["filter[forwarder_type]"] = params.forwarderType;
@@ -19957,10 +20115,15 @@ var ForwardersClient = class {
       wrapFetchError4(err);
     }
     return {
-      forwarders: (data?.data ?? []).map(_forwarderFromResource),
+      forwarders: (data?.data ?? []).map((r) => _forwarderFromResource(r, this)),
       pagination: _paginationFromBody2(data ?? {})
     };
   }
+  /**
+   * Fetch a single forwarder by id. The returned instance is bound to
+   * this client so {@link Forwarder.save} and {@link Forwarder.delete}
+   * round-trip back here.
+   */
   async get(forwarderId) {
     let data;
     try {
@@ -19973,41 +20136,67 @@ var ForwardersClient = class {
       wrapFetchError4(err);
     }
     if (!data?.data) throw new SmplError("Unexpected empty response from audit");
-    return _forwarderFromResource(data.data);
+    return _forwarderFromResource(data.data, this);
+  }
+  /** Soft-delete a forwarder by id. */
+  async delete(forwarderId) {
+    try {
+      const result = await this._http.DELETE("/api/v1/forwarders/{forwarder_id}", {
+        params: { path: { forwarder_id: forwarderId } }
+      });
+      if (result.response.status !== 204) await checkError4(result.response);
+    } catch (err) {
+      wrapFetchError4(err);
+    }
   }
   /**
-   * Full-replace update. PUT semantics — every field is overwritten.
-   *
-   * Header values must be re-supplied as plaintext; the GET path
-   * returns them in plaintext for exactly this round-trip.
+   * @internal Called by `Forwarder.save()` on unsaved instances.
    */
-  async update(forwarderId, input) {
+  async _createForwarder(forwarder) {
     const body = {
-      data: { id: forwarderId, type: "forwarder", attributes: _forwarderAttributes(input) }
+      data: { id: "", type: "forwarder", attributes: _forwarderAttrs(forwarder) }
     };
     let data;
     try {
-      const result = await this._http.PUT("/api/v1/forwarders/{forwarder_id}", {
-        params: { path: { forwarder_id: forwarderId } },
-        body
-      });
+      const result = await this._http.POST("/api/v1/forwarders", { body });
       if (!result.response.ok) await checkError4(result.response);
       data = result.data;
     } catch (err) {
       wrapFetchError4(err);
     }
     if (!data?.data) throw new SmplError("Unexpected empty response from audit");
-    return _forwarderFromResource(data.data);
+    return _forwarderFromResource(data.data, this);
   }
-  async delete(forwarderId) {
+  /**
+   * @internal Full-replace PUT. Called by `Forwarder.save()` on
+   * instances that already have a `createdAt`. Header values must be
+   * re-supplied as plaintext; the GET path redacts them, so a PUT body
+   * containing `"<redacted>"` would persist that literal.
+   */
+  async _updateForwarder(forwarder) {
+    if (forwarder.id === null) {
+      throw new Error("cannot update a Forwarder with no id");
+    }
+    const body = {
+      data: { id: forwarder.id, type: "forwarder", attributes: _forwarderAttrs(forwarder) }
+    };
+    let data;
     try {
-      const result = await this._http.DELETE("/api/v1/forwarders/{forwarder_id}", {
-        params: { path: { forwarder_id: forwarderId } }
+      const result = await this._http.PUT("/api/v1/forwarders/{forwarder_id}", {
+        params: { path: { forwarder_id: forwarder.id } },
+        body
       });
-      if (result.response.status !== 204) await checkError4(result.response);
+      if (!result.response.ok) await checkError4(result.response);
+      data = result.data;
     } catch (err) {
       wrapFetchError4(err);
     }
+    if (!data?.data) throw new SmplError("Unexpected empty response from audit");
+    return _forwarderFromResource(data.data, this);
+  }
+  /** @internal Called by `Forwarder.delete()`. */
+  async _deleteForwarder(id) {
+    return this.delete(id);
   }
 };
 var ManagementAuditClient = class {