@mpgd/cli 0.55.0 → 0.57.0

package/dist/native-build-target.js

@@ -4601,6 +4601,12 @@ var notificationTimeFields = {
   NotificationConsentRecord: { at: "date-time" },
   NotificationNotice: noticeTimeFields,
   RecordNotificationNoticeInput: noticeTimeFields,
+  NotificationBackendBridgeRecordConsentPayload: { record: { at: "date-time" } },
+  NotificationBackendBridgeRecordConsentResult: { record: { at: "date-time" } },
+  NotificationBackendBridgeListConsentResult: { records: { at: "date-time" } },
+  NotificationBackendBridgeListNoticesResult: { notices: noticeTimeFields },
+  NotificationBackendBridgeRecordNoticePayload: { notice: noticeTimeFields },
+  NotificationBackendBridgeSetReminderPayload: { reminder: { fireAt: "date-time" } },
   NotificationConformanceVector: {
     context: { now: "date-time" },
     steps: {
@@ -4717,6 +4723,17 @@ var notificationBridgeMethods = Object.freeze([
   "notifications.v2.listLocal",
   "notifications.v2.openSettings"
 ]);
+var notificationBackendBridgeMethods = Object.freeze([
+  "notifications.backend.getSession",
+  "notifications.backend.recordConsent",
+  "notifications.backend.listConsent",
+  "notifications.backend.registerEndpoint",
+  "notifications.backend.unregisterEndpoint",
+  "notifications.backend.setReminder",
+  "notifications.backend.cancelReminder",
+  "notifications.backend.listNotices",
+  "notifications.backend.recordNotice"
+]);
 function withStrictTimes(what, assert, fields) {
   return (input) => {
     const value = assert(input);
@@ -5298,7 +5315,1977 @@ var assertNotificationNotice = withStrictTimes("notice", /* @__PURE__ */ (() =>
     path: _path + ".record",
     expected: _ae0,
     value: input.record
-  }, _errorFactory)) && _ao1(input.record, _path + ".record", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao1(input.record, _path + ".record", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".record",
+    expected: _ae0,
+    value: input.record
+  }, _errorFactory)) && ("string" === typeof input.dueBy && (_isFormatDate_1._isFormatDate(input.dueBy) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".dueBy",
+    expected: 'string & Format<"date">',
+    value: input.dueBy
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".dueBy",
+    expected: '(string & Format<"date">)',
+    value: input.dueBy
+  }, _errorFactory)) && ("consent-result.advertising.granted" === input.variant || "consent-result.advertising.refused" === input.variant || "consent-result.advertising.withdrawn" === input.variant || "consent-result.night.granted" === input.variant || "consent-result.night.refused" === input.variant || "consent-result.night.withdrawn" === input.variant || "reconfirmation.advertising" === input.variant || "reconfirmation.night" === input.variant || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".variant",
+    expected: _ae1,
+    value: input.variant
+  }, _errorFactory)) && (4 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "record", "dueBy", "variant"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao1 = (input, _path, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '("advertising" | "night")',
+    value: input.kind
+  }, _errorFactory)) && ("granted" === input.state || "withdrawn" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".state",
+    expected: '("granted" | "withdrawn")',
+    value: input.state
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && (void 0 === input.textVersion || "string" === typeof input.textVersion && (1 <= input.textVersion.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "string & MinLength<1>",
+    value: input.textVersion
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "((string & MinLength<1>) | undefined)",
+    value: input.textVersion
+  }, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "state", "at", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _io0 = (input, _exceptionable = true) => ("consent-result" === input.kind || "reconfirmation" === input.kind) && ("object" === typeof input.record && null !== input.record && _io1(input.record, _exceptionable)) && ("string" === typeof input.dueBy && _isFormatDate_1._isFormatDate(input.dueBy)) && ("consent-result.advertising.granted" === input.variant || "consent-result.advertising.refused" === input.variant || "consent-result.advertising.withdrawn" === input.variant || "consent-result.night.granted" === input.variant || "consent-result.night.refused" === input.variant || "consent-result.night.withdrawn" === input.variant || "reconfirmation.advertising" === input.variant || "reconfirmation.night" === input.variant) && (4 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "record", "dueBy", "variant"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io1 = (input, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind) && ("granted" === input.state || "withdrawn" === input.state) && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (void 0 === input.textVersion || "string" === typeof input.textVersion && 1 <= input.textVersion.length) && (3 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "state", "at", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true);
+  let _errorFactory;
+  return (input, errorFactory) => {
+    if (false === __is(input)) {
+      _errorFactory = errorFactory;
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "NotificationNotice",
+        value: input2
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "NotificationNotice",
+        value: input2
+      }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+  };
+})(), notificationTimeFields.NotificationNotice);
+var assertRecordNotificationNoticeInput = withStrictTimes("notice to record", /* @__PURE__ */ (() => {
+  const _ae0 = '{ readonly kind: "advertising" | "night"; readonly state: "granted" | "withdrawn"; readonly at: IsoDateTime; readonly textVersion?: NonEmptyString; }';
+  const _ae1 = '("consent-result.advertising.granted" | "consent-result.advertising.refused" | "consent-result.advertising.withdrawn" | "consent-result.night.granted" | "consent-result.night.refused" | "consent-result.night.withdrawn" | "reconfirmation.advertising" | "reconfirmation.night")';
+  const _ao0 = (input, _path, _exceptionable = true) => ("consent-result" === input.kind || "reconfirmation" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '("consent-result" | "reconfirmation")',
+    value: input.kind
+  }, _errorFactory)) && (("object" === typeof input.record && null !== input.record || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".record",
+    expected: _ae0,
+    value: input.record
+  }, _errorFactory)) && _ao1(input.record, _path + ".record", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".record",
+    expected: _ae0,
+    value: input.record
+  }, _errorFactory)) && ("string" === typeof input.dueBy && (_isFormatDate_1._isFormatDate(input.dueBy) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".dueBy",
+    expected: 'string & Format<"date">',
+    value: input.dueBy
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".dueBy",
+    expected: '(string & Format<"date">)',
+    value: input.dueBy
+  }, _errorFactory)) && ("consent-result.advertising.granted" === input.variant || "consent-result.advertising.refused" === input.variant || "consent-result.advertising.withdrawn" === input.variant || "consent-result.night.granted" === input.variant || "consent-result.night.refused" === input.variant || "consent-result.night.withdrawn" === input.variant || "reconfirmation.advertising" === input.variant || "reconfirmation.night" === input.variant || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".variant",
+    expected: _ae1,
+    value: input.variant
+  }, _errorFactory)) && (4 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "record", "dueBy", "variant"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao1 = (input, _path, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '("advertising" | "night")',
+    value: input.kind
+  }, _errorFactory)) && ("granted" === input.state || "withdrawn" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".state",
+    expected: '("granted" | "withdrawn")',
+    value: input.state
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && (void 0 === input.textVersion || "string" === typeof input.textVersion && (1 <= input.textVersion.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "string & MinLength<1>",
+    value: input.textVersion
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "((string & MinLength<1>) | undefined)",
+    value: input.textVersion
+  }, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "state", "at", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao2 = (input, _path, _exceptionable = true) => ("consent-result" === input.kind || "reconfirmation" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '("consent-result" | "reconfirmation")',
+    value: input.kind
+  }, _errorFactory)) && (("object" === typeof input.record && null !== input.record || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".record",
+    expected: '{ readonly kind: "advertising" | "night"; readonly at: IsoDateTime; }',
+    value: input.record
+  }, _errorFactory)) && _ao3(input.record, _path + ".record", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".record",
+    expected: '{ readonly kind: "advertising" | "night"; readonly at: IsoDateTime; }',
+    value: input.record
+  }, _errorFactory)) && ("string" === typeof input.dueBy && (_isFormatDate_1._isFormatDate(input.dueBy) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".dueBy",
+    expected: 'string & Format<"date">',
+    value: input.dueBy
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".dueBy",
+    expected: '(string & Format<"date">)',
+    value: input.dueBy
+  }, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "record", "dueBy"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao3 = (input, _path, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '("advertising" | "night")',
+    value: input.kind
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "at"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if (void 0 !== input.variant)
+      return _ao0(input, _path, _exceptionable);
+    else
+      return _ao2(input, _path, _exceptionable);
+  })();
+  const _io0 = (input, _exceptionable = true) => ("consent-result" === input.kind || "reconfirmation" === input.kind) && ("object" === typeof input.record && null !== input.record && _io1(input.record, _exceptionable)) && ("string" === typeof input.dueBy && _isFormatDate_1._isFormatDate(input.dueBy)) && ("consent-result.advertising.granted" === input.variant || "consent-result.advertising.refused" === input.variant || "consent-result.advertising.withdrawn" === input.variant || "consent-result.night.granted" === input.variant || "consent-result.night.refused" === input.variant || "consent-result.night.withdrawn" === input.variant || "reconfirmation.advertising" === input.variant || "reconfirmation.night" === input.variant) && (4 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "record", "dueBy", "variant"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io1 = (input, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind) && ("granted" === input.state || "withdrawn" === input.state) && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (void 0 === input.textVersion || "string" === typeof input.textVersion && 1 <= input.textVersion.length) && (3 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "state", "at", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io2 = (input, _exceptionable = true) => ("consent-result" === input.kind || "reconfirmation" === input.kind) && ("object" === typeof input.record && null !== input.record && _io3(input.record, _exceptionable)) && ("string" === typeof input.dueBy && _isFormatDate_1._isFormatDate(input.dueBy)) && (3 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "record", "dueBy"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io3 = (input, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind) && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (2 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "at"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _iu0 = (input, _exceptionable = true) => (() => {
+    if (void 0 !== input.variant)
+      return _io0(input, _exceptionable);
+    else
+      return _io2(input, _exceptionable);
+  })();
+  const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _iu0(input, true);
+  let _errorFactory;
+  return (input, errorFactory) => {
+    if (false === __is(input)) {
+      _errorFactory = errorFactory;
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "(NotificationNotice | NotificationNoticeIdentity)",
+        value: input2
+      }, _errorFactory)) && _au0(input2, _path + "", true) || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "(NotificationNotice | NotificationNoticeIdentity)",
+        value: input2
+      }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+  };
+})(), notificationTimeFields.RecordNotificationNoticeInput);
+var assertNotificationBridgeListLocalResult = withStrictTimes("listLocal result", /* @__PURE__ */ (() => {
+  const _ao0 = (input, _path, _exceptionable = true) => ((Array.isArray(input.pending) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".pending",
+    expected: "ReadonlyArray<LocalNotificationEntry>",
+    value: input.pending
+  }, _errorFactory)) && input.pending.every((elem, _index2) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".pending[" + _index2 + "]",
+    expected: "LocalNotificationEntry",
+    value: elem
+  }, _errorFactory)) && _ao1(elem, _path + ".pending[" + _index2 + "]", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".pending[" + _index2 + "]",
+    expected: "LocalNotificationEntry",
+    value: elem
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".pending",
+    expected: "ReadonlyArray<LocalNotificationEntry>",
+    value: input.pending
+  }, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["pending"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.key && (1 <= input.key.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".key",
+    expected: "string & CommerceMinLength<1>",
+    value: input.key
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".key",
+    expected: "(string & CommerceMinLength<1>)",
+    value: input.key
+  }, _errorFactory)) && ("string" === typeof input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "string",
+    value: input.topic
+  }, _errorFactory)) && ("string" === typeof input.fireAt && (_isFormatDateTime_1._isFormatDateTime(input.fireAt) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".fireAt",
+    expected: "string & CommerceDateTimeFormat",
+    value: input.fireAt
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".fireAt",
+    expected: "(string & CommerceDateTimeFormat)",
+    value: input.fireAt
+  }, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["key", "topic", "fireAt"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _io0 = (input, _exceptionable = true) => Array.isArray(input.pending) && input.pending.every((elem, _index1) => "object" === typeof elem && null !== elem && _io1(elem, _exceptionable)) && (1 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["pending"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io1 = (input, _exceptionable = true) => "string" === typeof input.key && 1 <= input.key.length && "string" === typeof input.topic && ("string" === typeof input.fireAt && _isFormatDateTime_1._isFormatDateTime(input.fireAt)) && (3 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["key", "topic", "fireAt"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true);
+  let _errorFactory;
+  return (input, errorFactory) => {
+    if (false === __is(input)) {
+      _errorFactory = errorFactory;
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "NotificationBridgeListLocalResult",
+        value: input2
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "NotificationBridgeListLocalResult",
+        value: input2
+      }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+  };
+})(), notificationTimeFields.NotificationBridgeListLocalResult);
+var assertNotificationBackendBridgeRecordConsentPayload = withStrictTimes("recordConsent payload", /* @__PURE__ */ (() => {
+  const _ae0 = '({ readonly kind: "advertising" | "night"; readonly topic?: never; readonly state: "granted" | "withdrawn"; readonly source: "player"; readonly at: IsoDateTime; readonly evidence?: never; readonly textVersion: NonEmptyString; } | { readonly kind: "delivery-permission"; readonly topic?: never; readonly state: NotificationRecordablePermissionState; readonly source: "client-report" | "player"; readonly at: IsoDateTime; readonly evidence?: PlatformEvidenceEnvelope; readonly textVersion?: never; } | { readonly kind: "host-agreement"; readonly topic: NonEmptyString; readonly state: NotificationRecordablePermissionState; readonly source: "client-report" | "provider"; readonly at: IsoDateTime; readonly evidence?: PlatformEvidenceEnvelope; readonly textVersion?: never; } | { readonly kind: "topic-preference"; readonly topic: NonEmptyString; readonly state: "granted" | "withdrawn"; readonly source: "player"; readonly at: IsoDateTime; readonly evidence?: never; readonly textVersion?: never; })';
+  const _ae1 = '({ readonly kind: "advertising" | "night"; readonly topic?: never; readonly state: "granted" | "withdrawn"; readonly source: "player"; readonly at: IsoDateTime; readonly evidence?: never; readonly textVersion: NonEmptyString; } | { readonly kind: "topic-preference"; readonly topic: NonEmptyString; readonly state: "granted" | "withdrawn"; readonly source: "player"; readonly at: IsoDateTime; readonly evidence?: never; readonly textVersion?: never; } | { readonly kind: "host-agreement"; readonly topic: NonEmptyString; readonly state: NotificationRecordablePermissionState; readonly source: "client-report" | "provider"; readonly at: IsoDateTime; readonly evidence?: PlatformEvidenceEnvelope; readonly textVersion?: never; } | { readonly kind: "delivery-permission"; readonly topic?: never; readonly state: NotificationRecordablePermissionState; readonly source: "client-report" | "player"; readonly at: IsoDateTime; readonly evidence?: PlatformEvidenceEnvelope; readonly textVersion?: never; })';
+  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.expectedPlayer && (1 <= input.expectedPlayer.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".expectedPlayer",
+    expected: "string & MinLength<1>",
+    value: input.expectedPlayer
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".expectedPlayer",
+    expected: "(string & MinLength<1>)",
+    value: input.expectedPlayer
+  }, _errorFactory)) && (("object" === typeof input.record && null !== input.record || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".record",
+    expected: _ae0,
+    value: input.record
+  }, _errorFactory)) && _au0(input.record, _path + ".record", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".record",
+    expected: _ae0,
+    value: input.record
+  }, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["expectedPlayer", "record"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao1 = (input, _path, _exceptionable = true) => ("delivery-permission" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '"delivery-permission"',
+    value: input.kind
+  }, _errorFactory)) && ((null !== input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "undefined",
+    value: input.topic
+  }, _errorFactory)) && (void 0 === input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "undefined",
+    value: input.topic
+  }, _errorFactory))) && ("blocked" === input.state || "denied" === input.state || "granted" === input.state || "prompt-with-rationale" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".state",
+    expected: '("blocked" | "denied" | "granted" | "prompt-with-rationale")',
+    value: input.state
+  }, _errorFactory)) && ("client-report" === input.source || "player" === input.source || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".source",
+    expected: '("client-report" | "player")',
+    value: input.source
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && (void 0 === input.evidence || ("object" === typeof input.evidence && null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "(PlatformEvidenceEnvelope | undefined)",
+    value: input.evidence
+  }, _errorFactory)) && _ao2(input.evidence, _path + ".evidence", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "(PlatformEvidenceEnvelope | undefined)",
+    value: input.evidence
+  }, _errorFactory)) && ((null !== input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory)) && (void 0 === input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory))) && (4 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.schema || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".schema",
+    expected: "string",
+    value: input.schema
+  }, _errorFactory)) && (("object" === typeof input.payload && null !== input.payload && false === Array.isArray(input.payload) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".payload",
+    expected: "Readonly<Record<string, string | number | boolean>>",
+    value: input.payload
+  }, _errorFactory)) && _ao3(input.payload, _path + ".payload", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".payload",
+    expected: "Readonly<Record<string, string | number | boolean>>",
+    value: input.payload
+  }, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["schema", "payload"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao3 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every((key) => {
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return "string" === typeof value || "number" === typeof value || "boolean" === typeof value || _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + __typia_transform__accessExpressionAsString(key),
+      expected: "(boolean | number | string)",
+      value
+    }, _errorFactory);
+  });
+  const _ao4 = (input, _path, _exceptionable = true) => ("host-agreement" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '"host-agreement"',
+    value: input.kind
+  }, _errorFactory)) && ("string" === typeof input.topic && (1 <= input.topic.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "string & MinLength<1>",
+    value: input.topic
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "(string & MinLength<1>)",
+    value: input.topic
+  }, _errorFactory)) && ("blocked" === input.state || "denied" === input.state || "granted" === input.state || "prompt-with-rationale" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".state",
+    expected: '("blocked" | "denied" | "granted" | "prompt-with-rationale")',
+    value: input.state
+  }, _errorFactory)) && ("client-report" === input.source || "provider" === input.source || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".source",
+    expected: '("client-report" | "provider")',
+    value: input.source
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && (void 0 === input.evidence || ("object" === typeof input.evidence && null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "(PlatformEvidenceEnvelope | undefined)",
+    value: input.evidence
+  }, _errorFactory)) && _ao2(input.evidence, _path + ".evidence", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "(PlatformEvidenceEnvelope | undefined)",
+    value: input.evidence
+  }, _errorFactory)) && ((null !== input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory)) && (void 0 === input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory))) && (5 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao5 = (input, _path, _exceptionable = true) => ("topic-preference" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '"topic-preference"',
+    value: input.kind
+  }, _errorFactory)) && ("string" === typeof input.topic && (1 <= input.topic.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "string & MinLength<1>",
+    value: input.topic
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "(string & MinLength<1>)",
+    value: input.topic
+  }, _errorFactory)) && ("granted" === input.state || "withdrawn" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".state",
+    expected: '("granted" | "withdrawn")',
+    value: input.state
+  }, _errorFactory)) && ("player" === input.source || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".source",
+    expected: '"player"',
+    value: input.source
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && ((null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "undefined",
+    value: input.evidence
+  }, _errorFactory)) && (void 0 === input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "undefined",
+    value: input.evidence
+  }, _errorFactory))) && ((null !== input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory)) && (void 0 === input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory))) && (5 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao6 = (input, _path, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '("advertising" | "night")',
+    value: input.kind
+  }, _errorFactory)) && ((null !== input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "undefined",
+    value: input.topic
+  }, _errorFactory)) && (void 0 === input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "undefined",
+    value: input.topic
+  }, _errorFactory))) && ("granted" === input.state || "withdrawn" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".state",
+    expected: '("granted" | "withdrawn")',
+    value: input.state
+  }, _errorFactory)) && ("player" === input.source || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".source",
+    expected: '"player"',
+    value: input.source
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && ((null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "undefined",
+    value: input.evidence
+  }, _errorFactory)) && (void 0 === input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "undefined",
+    value: input.evidence
+  }, _errorFactory))) && ("string" === typeof input.textVersion && (1 <= input.textVersion.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "string & MinLength<1>",
+    value: input.textVersion
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "(string & MinLength<1>)",
+    value: input.textVersion
+  }, _errorFactory)) && (5 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if ("advertising" === input.kind || "night" === input.kind)
+      return _ao6(input, _path, _exceptionable);
+    else if ("topic-preference" === input.kind)
+      return _ao5(input, _path, _exceptionable);
+    else if ("host-agreement" === input.kind)
+      return _ao4(input, _path, _exceptionable);
+    else if ("delivery-permission" === input.kind)
+      return _ao1(input, _path, _exceptionable);
+    else
+      return _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path,
+        expected: _ae1,
+        value: input
+      }, _errorFactory);
+  })();
+  const _io0 = (input, _exceptionable = true) => "string" === typeof input.expectedPlayer && 1 <= input.expectedPlayer.length && ("object" === typeof input.record && null !== input.record && _iu0(input.record, _exceptionable)) && (2 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["expectedPlayer", "record"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io1 = (input, _exceptionable = true) => "delivery-permission" === input.kind && (null !== input.topic && void 0 === input.topic) && ("blocked" === input.state || "denied" === input.state || "granted" === input.state || "prompt-with-rationale" === input.state) && ("client-report" === input.source || "player" === input.source) && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (void 0 === input.evidence || "object" === typeof input.evidence && null !== input.evidence && _io2(input.evidence, _exceptionable)) && (null !== input.textVersion && void 0 === input.textVersion) && (4 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io2 = (input, _exceptionable = true) => "string" === typeof input.schema && ("object" === typeof input.payload && null !== input.payload && false === Array.isArray(input.payload) && _io3(input.payload, _exceptionable)) && (2 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["schema", "payload"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io3 = (input, _exceptionable = true) => Object.keys(input).every((key) => {
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return "string" === typeof value || "number" === typeof value || "boolean" === typeof value;
+  });
+  const _io4 = (input, _exceptionable = true) => "host-agreement" === input.kind && ("string" === typeof input.topic && 1 <= input.topic.length) && ("blocked" === input.state || "denied" === input.state || "granted" === input.state || "prompt-with-rationale" === input.state) && ("client-report" === input.source || "provider" === input.source) && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (void 0 === input.evidence || "object" === typeof input.evidence && null !== input.evidence && _io2(input.evidence, _exceptionable)) && (null !== input.textVersion && void 0 === input.textVersion) && (5 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io5 = (input, _exceptionable = true) => "topic-preference" === input.kind && ("string" === typeof input.topic && 1 <= input.topic.length) && ("granted" === input.state || "withdrawn" === input.state) && "player" === input.source && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (null !== input.evidence && void 0 === input.evidence) && (null !== input.textVersion && void 0 === input.textVersion) && (5 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io6 = (input, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind) && (null !== input.topic && void 0 === input.topic) && ("granted" === input.state || "withdrawn" === input.state) && "player" === input.source && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (null !== input.evidence && void 0 === input.evidence) && ("string" === typeof input.textVersion && 1 <= input.textVersion.length) && (5 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _iu0 = (input, _exceptionable = true) => (() => {
+    if ("advertising" === input.kind || "night" === input.kind)
+      return _io6(input, _exceptionable);
+    else if ("topic-preference" === input.kind)
+      return _io5(input, _exceptionable);
+    else if ("host-agreement" === input.kind)
+      return _io4(input, _exceptionable);
+    else if ("delivery-permission" === input.kind)
+      return _io1(input, _exceptionable);
+    else
+      return false;
+  })();
+  const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true);
+  let _errorFactory;
+  return (input, errorFactory) => {
+    if (false === __is(input)) {
+      _errorFactory = errorFactory;
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "NotificationBackendBridgeRecordConsentPayload",
+        value: input2
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "NotificationBackendBridgeRecordConsentPayload",
+        value: input2
+      }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+  };
+})(), notificationTimeFields.NotificationBackendBridgeRecordConsentPayload);
+var assertNotificationBackendBridgeRecordConsentResult = withStrictTimes("recordConsent result", /* @__PURE__ */ (() => {
+  const _ae0 = '({ readonly kind: "advertising" | "night"; readonly topic?: never; readonly state: "granted" | "withdrawn"; readonly source: "player"; readonly at: IsoDateTime; readonly evidence?: never; readonly textVersion: NonEmptyString; } | { readonly kind: "delivery-permission"; readonly topic?: never; readonly state: NotificationRecordablePermissionState; readonly source: "client-report" | "player"; readonly at: IsoDateTime; readonly evidence?: PlatformEvidenceEnvelope; readonly textVersion?: never; } | { readonly kind: "host-agreement"; readonly topic: NonEmptyString; readonly state: NotificationRecordablePermissionState; readonly source: "client-report" | "provider"; readonly at: IsoDateTime; readonly evidence?: PlatformEvidenceEnvelope; readonly textVersion?: never; } | { readonly kind: "topic-preference"; readonly topic: NonEmptyString; readonly state: "granted" | "withdrawn"; readonly source: "player"; readonly at: IsoDateTime; readonly evidence?: never; readonly textVersion?: never; })';
+  const _ae1 = '({ readonly kind: "advertising" | "night"; readonly topic?: never; readonly state: "granted" | "withdrawn"; readonly source: "player"; readonly at: IsoDateTime; readonly evidence?: never; readonly textVersion: NonEmptyString; } | { readonly kind: "topic-preference"; readonly topic: NonEmptyString; readonly state: "granted" | "withdrawn"; readonly source: "player"; readonly at: IsoDateTime; readonly evidence?: never; readonly textVersion?: never; } | { readonly kind: "host-agreement"; readonly topic: NonEmptyString; readonly state: NotificationRecordablePermissionState; readonly source: "client-report" | "provider"; readonly at: IsoDateTime; readonly evidence?: PlatformEvidenceEnvelope; readonly textVersion?: never; } | { readonly kind: "delivery-permission"; readonly topic?: never; readonly state: NotificationRecordablePermissionState; readonly source: "client-report" | "player"; readonly at: IsoDateTime; readonly evidence?: PlatformEvidenceEnvelope; readonly textVersion?: never; })';
+  const _ao0 = (input, _path, _exceptionable = true) => (("object" === typeof input.record && null !== input.record || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".record",
+    expected: _ae0,
+    value: input.record
+  }, _errorFactory)) && _au0(input.record, _path + ".record", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".record",
+    expected: _ae0,
+    value: input.record
+  }, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["record"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao1 = (input, _path, _exceptionable = true) => ("delivery-permission" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '"delivery-permission"',
+    value: input.kind
+  }, _errorFactory)) && ((null !== input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "undefined",
+    value: input.topic
+  }, _errorFactory)) && (void 0 === input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "undefined",
+    value: input.topic
+  }, _errorFactory))) && ("blocked" === input.state || "denied" === input.state || "granted" === input.state || "prompt-with-rationale" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".state",
+    expected: '("blocked" | "denied" | "granted" | "prompt-with-rationale")',
+    value: input.state
+  }, _errorFactory)) && ("client-report" === input.source || "player" === input.source || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".source",
+    expected: '("client-report" | "player")',
+    value: input.source
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && (void 0 === input.evidence || ("object" === typeof input.evidence && null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "(PlatformEvidenceEnvelope | undefined)",
+    value: input.evidence
+  }, _errorFactory)) && _ao2(input.evidence, _path + ".evidence", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "(PlatformEvidenceEnvelope | undefined)",
+    value: input.evidence
+  }, _errorFactory)) && ((null !== input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory)) && (void 0 === input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory))) && (4 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.schema || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".schema",
+    expected: "string",
+    value: input.schema
+  }, _errorFactory)) && (("object" === typeof input.payload && null !== input.payload && false === Array.isArray(input.payload) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".payload",
+    expected: "Readonly<Record<string, string | number | boolean>>",
+    value: input.payload
+  }, _errorFactory)) && _ao3(input.payload, _path + ".payload", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".payload",
+    expected: "Readonly<Record<string, string | number | boolean>>",
+    value: input.payload
+  }, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["schema", "payload"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao3 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every((key) => {
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return "string" === typeof value || "number" === typeof value || "boolean" === typeof value || _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + __typia_transform__accessExpressionAsString(key),
+      expected: "(boolean | number | string)",
+      value
+    }, _errorFactory);
+  });
+  const _ao4 = (input, _path, _exceptionable = true) => ("host-agreement" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '"host-agreement"',
+    value: input.kind
+  }, _errorFactory)) && ("string" === typeof input.topic && (1 <= input.topic.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "string & MinLength<1>",
+    value: input.topic
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "(string & MinLength<1>)",
+    value: input.topic
+  }, _errorFactory)) && ("blocked" === input.state || "denied" === input.state || "granted" === input.state || "prompt-with-rationale" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".state",
+    expected: '("blocked" | "denied" | "granted" | "prompt-with-rationale")',
+    value: input.state
+  }, _errorFactory)) && ("client-report" === input.source || "provider" === input.source || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".source",
+    expected: '("client-report" | "provider")',
+    value: input.source
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && (void 0 === input.evidence || ("object" === typeof input.evidence && null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "(PlatformEvidenceEnvelope | undefined)",
+    value: input.evidence
+  }, _errorFactory)) && _ao2(input.evidence, _path + ".evidence", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "(PlatformEvidenceEnvelope | undefined)",
+    value: input.evidence
+  }, _errorFactory)) && ((null !== input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory)) && (void 0 === input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory))) && (5 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao5 = (input, _path, _exceptionable = true) => ("topic-preference" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '"topic-preference"',
+    value: input.kind
+  }, _errorFactory)) && ("string" === typeof input.topic && (1 <= input.topic.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "string & MinLength<1>",
+    value: input.topic
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "(string & MinLength<1>)",
+    value: input.topic
+  }, _errorFactory)) && ("granted" === input.state || "withdrawn" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".state",
+    expected: '("granted" | "withdrawn")',
+    value: input.state
+  }, _errorFactory)) && ("player" === input.source || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".source",
+    expected: '"player"',
+    value: input.source
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && ((null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "undefined",
+    value: input.evidence
+  }, _errorFactory)) && (void 0 === input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "undefined",
+    value: input.evidence
+  }, _errorFactory))) && ((null !== input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory)) && (void 0 === input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory))) && (5 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao6 = (input, _path, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '("advertising" | "night")',
+    value: input.kind
+  }, _errorFactory)) && ((null !== input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "undefined",
+    value: input.topic
+  }, _errorFactory)) && (void 0 === input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "undefined",
+    value: input.topic
+  }, _errorFactory))) && ("granted" === input.state || "withdrawn" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".state",
+    expected: '("granted" | "withdrawn")',
+    value: input.state
+  }, _errorFactory)) && ("player" === input.source || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".source",
+    expected: '"player"',
+    value: input.source
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && ((null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "undefined",
+    value: input.evidence
+  }, _errorFactory)) && (void 0 === input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "undefined",
+    value: input.evidence
+  }, _errorFactory))) && ("string" === typeof input.textVersion && (1 <= input.textVersion.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "string & MinLength<1>",
+    value: input.textVersion
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "(string & MinLength<1>)",
+    value: input.textVersion
+  }, _errorFactory)) && (5 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if ("advertising" === input.kind || "night" === input.kind)
+      return _ao6(input, _path, _exceptionable);
+    else if ("topic-preference" === input.kind)
+      return _ao5(input, _path, _exceptionable);
+    else if ("host-agreement" === input.kind)
+      return _ao4(input, _path, _exceptionable);
+    else if ("delivery-permission" === input.kind)
+      return _ao1(input, _path, _exceptionable);
+    else
+      return _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path,
+        expected: _ae1,
+        value: input
+      }, _errorFactory);
+  })();
+  const _io0 = (input, _exceptionable = true) => "object" === typeof input.record && null !== input.record && _iu0(input.record, _exceptionable) && (1 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["record"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io1 = (input, _exceptionable = true) => "delivery-permission" === input.kind && (null !== input.topic && void 0 === input.topic) && ("blocked" === input.state || "denied" === input.state || "granted" === input.state || "prompt-with-rationale" === input.state) && ("client-report" === input.source || "player" === input.source) && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (void 0 === input.evidence || "object" === typeof input.evidence && null !== input.evidence && _io2(input.evidence, _exceptionable)) && (null !== input.textVersion && void 0 === input.textVersion) && (4 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io2 = (input, _exceptionable = true) => "string" === typeof input.schema && ("object" === typeof input.payload && null !== input.payload && false === Array.isArray(input.payload) && _io3(input.payload, _exceptionable)) && (2 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["schema", "payload"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io3 = (input, _exceptionable = true) => Object.keys(input).every((key) => {
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return "string" === typeof value || "number" === typeof value || "boolean" === typeof value;
+  });
+  const _io4 = (input, _exceptionable = true) => "host-agreement" === input.kind && ("string" === typeof input.topic && 1 <= input.topic.length) && ("blocked" === input.state || "denied" === input.state || "granted" === input.state || "prompt-with-rationale" === input.state) && ("client-report" === input.source || "provider" === input.source) && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (void 0 === input.evidence || "object" === typeof input.evidence && null !== input.evidence && _io2(input.evidence, _exceptionable)) && (null !== input.textVersion && void 0 === input.textVersion) && (5 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io5 = (input, _exceptionable = true) => "topic-preference" === input.kind && ("string" === typeof input.topic && 1 <= input.topic.length) && ("granted" === input.state || "withdrawn" === input.state) && "player" === input.source && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (null !== input.evidence && void 0 === input.evidence) && (null !== input.textVersion && void 0 === input.textVersion) && (5 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io6 = (input, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind) && (null !== input.topic && void 0 === input.topic) && ("granted" === input.state || "withdrawn" === input.state) && "player" === input.source && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (null !== input.evidence && void 0 === input.evidence) && ("string" === typeof input.textVersion && 1 <= input.textVersion.length) && (5 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _iu0 = (input, _exceptionable = true) => (() => {
+    if ("advertising" === input.kind || "night" === input.kind)
+      return _io6(input, _exceptionable);
+    else if ("topic-preference" === input.kind)
+      return _io5(input, _exceptionable);
+    else if ("host-agreement" === input.kind)
+      return _io4(input, _exceptionable);
+    else if ("delivery-permission" === input.kind)
+      return _io1(input, _exceptionable);
+    else
+      return false;
+  })();
+  const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true);
+  let _errorFactory;
+  return (input, errorFactory) => {
+    if (false === __is(input)) {
+      _errorFactory = errorFactory;
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "NotificationBackendBridgeRecordConsentResult",
+        value: input2
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "NotificationBackendBridgeRecordConsentResult",
+        value: input2
+      }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+  };
+})(), notificationTimeFields.NotificationBackendBridgeRecordConsentResult);
+var assertNotificationBackendBridgeListConsentResult = withStrictTimes("listConsent result", /* @__PURE__ */ (() => {
+  const _ae0 = '({ readonly kind: "advertising" | "night"; readonly topic?: never; readonly state: "granted" | "withdrawn"; readonly source: "player"; readonly at: IsoDateTime; readonly evidence?: never; readonly textVersion: NonEmptyString; } | { readonly kind: "delivery-permission"; readonly topic?: never; readonly state: NotificationRecordablePermissionState; readonly source: "client-report" | "player"; readonly at: IsoDateTime; readonly evidence?: PlatformEvidenceEnvelope; readonly textVersion?: never; } | { readonly kind: "host-agreement"; readonly topic: NonEmptyString; readonly state: NotificationRecordablePermissionState; readonly source: "client-report" | "provider"; readonly at: IsoDateTime; readonly evidence?: PlatformEvidenceEnvelope; readonly textVersion?: never; } | { readonly kind: "topic-preference"; readonly topic: NonEmptyString; readonly state: "granted" | "withdrawn"; readonly source: "player"; readonly at: IsoDateTime; readonly evidence?: never; readonly textVersion?: never; })';
+  const _ae1 = '({ readonly kind: "advertising" | "night"; readonly topic?: never; readonly state: "granted" | "withdrawn"; readonly source: "player"; readonly at: IsoDateTime; readonly evidence?: never; readonly textVersion: NonEmptyString; } | { readonly kind: "topic-preference"; readonly topic: NonEmptyString; readonly state: "granted" | "withdrawn"; readonly source: "player"; readonly at: IsoDateTime; readonly evidence?: never; readonly textVersion?: never; } | { readonly kind: "host-agreement"; readonly topic: NonEmptyString; readonly state: NotificationRecordablePermissionState; readonly source: "client-report" | "provider"; readonly at: IsoDateTime; readonly evidence?: PlatformEvidenceEnvelope; readonly textVersion?: never; } | { readonly kind: "delivery-permission"; readonly topic?: never; readonly state: NotificationRecordablePermissionState; readonly source: "client-report" | "player"; readonly at: IsoDateTime; readonly evidence?: PlatformEvidenceEnvelope; readonly textVersion?: never; })';
+  const _ao0 = (input, _path, _exceptionable = true) => ((Array.isArray(input.records) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".records",
+    expected: "ReadonlyArray<NotificationConsentRecord>",
+    value: input.records
+  }, _errorFactory)) && input.records.every((elem, _index2) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".records[" + _index2 + "]",
+    expected: _ae0,
+    value: elem
+  }, _errorFactory)) && _au0(elem, _path + ".records[" + _index2 + "]", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".records[" + _index2 + "]",
+    expected: _ae0,
+    value: elem
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".records",
+    expected: "ReadonlyArray<NotificationConsentRecord>",
+    value: input.records
+  }, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["records"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao1 = (input, _path, _exceptionable = true) => ("delivery-permission" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '"delivery-permission"',
+    value: input.kind
+  }, _errorFactory)) && ((null !== input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "undefined",
+    value: input.topic
+  }, _errorFactory)) && (void 0 === input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "undefined",
+    value: input.topic
+  }, _errorFactory))) && ("blocked" === input.state || "denied" === input.state || "granted" === input.state || "prompt-with-rationale" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".state",
+    expected: '("blocked" | "denied" | "granted" | "prompt-with-rationale")',
+    value: input.state
+  }, _errorFactory)) && ("client-report" === input.source || "player" === input.source || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".source",
+    expected: '("client-report" | "player")',
+    value: input.source
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && (void 0 === input.evidence || ("object" === typeof input.evidence && null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "(PlatformEvidenceEnvelope | undefined)",
+    value: input.evidence
+  }, _errorFactory)) && _ao2(input.evidence, _path + ".evidence", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "(PlatformEvidenceEnvelope | undefined)",
+    value: input.evidence
+  }, _errorFactory)) && ((null !== input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory)) && (void 0 === input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory))) && (4 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.schema || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".schema",
+    expected: "string",
+    value: input.schema
+  }, _errorFactory)) && (("object" === typeof input.payload && null !== input.payload && false === Array.isArray(input.payload) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".payload",
+    expected: "Readonly<Record<string, string | number | boolean>>",
+    value: input.payload
+  }, _errorFactory)) && _ao3(input.payload, _path + ".payload", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".payload",
+    expected: "Readonly<Record<string, string | number | boolean>>",
+    value: input.payload
+  }, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["schema", "payload"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao3 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every((key) => {
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return "string" === typeof value || "number" === typeof value || "boolean" === typeof value || _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + __typia_transform__accessExpressionAsString(key),
+      expected: "(boolean | number | string)",
+      value
+    }, _errorFactory);
+  });
+  const _ao4 = (input, _path, _exceptionable = true) => ("host-agreement" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '"host-agreement"',
+    value: input.kind
+  }, _errorFactory)) && ("string" === typeof input.topic && (1 <= input.topic.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "string & MinLength<1>",
+    value: input.topic
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "(string & MinLength<1>)",
+    value: input.topic
+  }, _errorFactory)) && ("blocked" === input.state || "denied" === input.state || "granted" === input.state || "prompt-with-rationale" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".state",
+    expected: '("blocked" | "denied" | "granted" | "prompt-with-rationale")',
+    value: input.state
+  }, _errorFactory)) && ("client-report" === input.source || "provider" === input.source || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".source",
+    expected: '("client-report" | "provider")',
+    value: input.source
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && (void 0 === input.evidence || ("object" === typeof input.evidence && null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "(PlatformEvidenceEnvelope | undefined)",
+    value: input.evidence
+  }, _errorFactory)) && _ao2(input.evidence, _path + ".evidence", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "(PlatformEvidenceEnvelope | undefined)",
+    value: input.evidence
+  }, _errorFactory)) && ((null !== input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory)) && (void 0 === input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory))) && (5 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao5 = (input, _path, _exceptionable = true) => ("topic-preference" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '"topic-preference"',
+    value: input.kind
+  }, _errorFactory)) && ("string" === typeof input.topic && (1 <= input.topic.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "string & MinLength<1>",
+    value: input.topic
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "(string & MinLength<1>)",
+    value: input.topic
+  }, _errorFactory)) && ("granted" === input.state || "withdrawn" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".state",
+    expected: '("granted" | "withdrawn")',
+    value: input.state
+  }, _errorFactory)) && ("player" === input.source || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".source",
+    expected: '"player"',
+    value: input.source
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && ((null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "undefined",
+    value: input.evidence
+  }, _errorFactory)) && (void 0 === input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "undefined",
+    value: input.evidence
+  }, _errorFactory))) && ((null !== input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory)) && (void 0 === input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory))) && (5 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao6 = (input, _path, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '("advertising" | "night")',
+    value: input.kind
+  }, _errorFactory)) && ((null !== input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "undefined",
+    value: input.topic
+  }, _errorFactory)) && (void 0 === input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "undefined",
+    value: input.topic
+  }, _errorFactory))) && ("granted" === input.state || "withdrawn" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".state",
+    expected: '("granted" | "withdrawn")',
+    value: input.state
+  }, _errorFactory)) && ("player" === input.source || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".source",
+    expected: '"player"',
+    value: input.source
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && ((null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "undefined",
+    value: input.evidence
+  }, _errorFactory)) && (void 0 === input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "undefined",
+    value: input.evidence
+  }, _errorFactory))) && ("string" === typeof input.textVersion && (1 <= input.textVersion.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "string & MinLength<1>",
+    value: input.textVersion
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "(string & MinLength<1>)",
+    value: input.textVersion
+  }, _errorFactory)) && (5 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if ("advertising" === input.kind || "night" === input.kind)
+      return _ao6(input, _path, _exceptionable);
+    else if ("topic-preference" === input.kind)
+      return _ao5(input, _path, _exceptionable);
+    else if ("host-agreement" === input.kind)
+      return _ao4(input, _path, _exceptionable);
+    else if ("delivery-permission" === input.kind)
+      return _ao1(input, _path, _exceptionable);
+    else
+      return _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path,
+        expected: _ae1,
+        value: input
+      }, _errorFactory);
+  })();
+  const _io0 = (input, _exceptionable = true) => Array.isArray(input.records) && input.records.every((elem, _index1) => "object" === typeof elem && null !== elem && _iu0(elem, _exceptionable)) && (1 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["records"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io1 = (input, _exceptionable = true) => "delivery-permission" === input.kind && (null !== input.topic && void 0 === input.topic) && ("blocked" === input.state || "denied" === input.state || "granted" === input.state || "prompt-with-rationale" === input.state) && ("client-report" === input.source || "player" === input.source) && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (void 0 === input.evidence || "object" === typeof input.evidence && null !== input.evidence && _io2(input.evidence, _exceptionable)) && (null !== input.textVersion && void 0 === input.textVersion) && (4 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io2 = (input, _exceptionable = true) => "string" === typeof input.schema && ("object" === typeof input.payload && null !== input.payload && false === Array.isArray(input.payload) && _io3(input.payload, _exceptionable)) && (2 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["schema", "payload"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io3 = (input, _exceptionable = true) => Object.keys(input).every((key) => {
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return "string" === typeof value || "number" === typeof value || "boolean" === typeof value;
+  });
+  const _io4 = (input, _exceptionable = true) => "host-agreement" === input.kind && ("string" === typeof input.topic && 1 <= input.topic.length) && ("blocked" === input.state || "denied" === input.state || "granted" === input.state || "prompt-with-rationale" === input.state) && ("client-report" === input.source || "provider" === input.source) && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (void 0 === input.evidence || "object" === typeof input.evidence && null !== input.evidence && _io2(input.evidence, _exceptionable)) && (null !== input.textVersion && void 0 === input.textVersion) && (5 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io5 = (input, _exceptionable = true) => "topic-preference" === input.kind && ("string" === typeof input.topic && 1 <= input.topic.length) && ("granted" === input.state || "withdrawn" === input.state) && "player" === input.source && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (null !== input.evidence && void 0 === input.evidence) && (null !== input.textVersion && void 0 === input.textVersion) && (5 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io6 = (input, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind) && (null !== input.topic && void 0 === input.topic) && ("granted" === input.state || "withdrawn" === input.state) && "player" === input.source && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (null !== input.evidence && void 0 === input.evidence) && ("string" === typeof input.textVersion && 1 <= input.textVersion.length) && (5 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _iu0 = (input, _exceptionable = true) => (() => {
+    if ("advertising" === input.kind || "night" === input.kind)
+      return _io6(input, _exceptionable);
+    else if ("topic-preference" === input.kind)
+      return _io5(input, _exceptionable);
+    else if ("host-agreement" === input.kind)
+      return _io4(input, _exceptionable);
+    else if ("delivery-permission" === input.kind)
+      return _io1(input, _exceptionable);
+    else
+      return false;
+  })();
+  const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true);
+  let _errorFactory;
+  return (input, errorFactory) => {
+    if (false === __is(input)) {
+      _errorFactory = errorFactory;
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "NotificationBackendBridgeListConsentResult",
+        value: input2
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "NotificationBackendBridgeListConsentResult",
+        value: input2
+      }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+  };
+})(), notificationTimeFields.NotificationBackendBridgeListConsentResult);
+var assertNotificationBackendBridgeSetReminderPayload = withStrictTimes("setReminder payload", /* @__PURE__ */ (() => {
+  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.expectedPlayer && (1 <= input.expectedPlayer.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".expectedPlayer",
+    expected: "string & MinLength<1>",
+    value: input.expectedPlayer
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".expectedPlayer",
+    expected: "(string & MinLength<1>)",
+    value: input.expectedPlayer
+  }, _errorFactory)) && (("object" === typeof input.reminder && null !== input.reminder || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".reminder",
+    expected: "NotificationBackendBridgeReminder",
+    value: input.reminder
+  }, _errorFactory)) && _ao1(input.reminder, _path + ".reminder", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".reminder",
+    expected: "NotificationBackendBridgeReminder",
+    value: input.reminder
+  }, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["expectedPlayer", "reminder"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "string",
+    value: input.topic
+  }, _errorFactory)) && (void 0 === input.templateData || ("object" === typeof input.templateData && null !== input.templateData && false === Array.isArray(input.templateData) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".templateData",
+    expected: "(Readonly<Record<string, string | number | boolean>> | undefined)",
+    value: input.templateData
+  }, _errorFactory)) && _ao2(input.templateData, _path + ".templateData", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".templateData",
+    expected: "(Readonly<Record<string, string | number | boolean>> | undefined)",
+    value: input.templateData
+  }, _errorFactory)) && ("string" === typeof input.key && (1 <= input.key.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".key",
+    expected: "string & MinLength<1>",
+    value: input.key
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".key",
+    expected: "(string & MinLength<1>)",
+    value: input.key
+  }, _errorFactory)) && ("string" === typeof input.fireAt && (_isFormatDateTime_1._isFormatDateTime(input.fireAt) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".fireAt",
+    expected: 'string & Format<"date-time">',
+    value: input.fireAt
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".fireAt",
+    expected: '(string & Format<"date-time">)',
+    value: input.fireAt
+  }, _errorFactory)) && (void 0 === input.link || "string" === typeof input.link && (1 <= input.link.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".link",
+    expected: "string & MinLength<1>",
+    value: input.link
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".link",
+    expected: "((string & MinLength<1>) | undefined)",
+    value: input.link
+  }, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["topic", "templateData", "key", "fireAt", "link"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao2 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every((key) => {
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return "string" === typeof value || "number" === typeof value || "boolean" === typeof value || _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + __typia_transform__accessExpressionAsString(key),
+      expected: "(boolean | number | string)",
+      value
+    }, _errorFactory);
+  });
+  const _io0 = (input, _exceptionable = true) => "string" === typeof input.expectedPlayer && 1 <= input.expectedPlayer.length && ("object" === typeof input.reminder && null !== input.reminder && _io1(input.reminder, _exceptionable)) && (2 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["expectedPlayer", "reminder"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io1 = (input, _exceptionable = true) => "string" === typeof input.topic && (void 0 === input.templateData || "object" === typeof input.templateData && null !== input.templateData && false === Array.isArray(input.templateData) && _io2(input.templateData, _exceptionable)) && ("string" === typeof input.key && 1 <= input.key.length) && ("string" === typeof input.fireAt && _isFormatDateTime_1._isFormatDateTime(input.fireAt)) && (void 0 === input.link || "string" === typeof input.link && 1 <= input.link.length) && (3 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["topic", "templateData", "key", "fireAt", "link"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io2 = (input, _exceptionable = true) => Object.keys(input).every((key) => {
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return "string" === typeof value || "number" === typeof value || "boolean" === typeof value;
+  });
+  const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true);
+  let _errorFactory;
+  return (input, errorFactory) => {
+    if (false === __is(input)) {
+      _errorFactory = errorFactory;
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "NotificationBackendBridgeSetReminderPayload",
+        value: input2
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "NotificationBackendBridgeSetReminderPayload",
+        value: input2
+      }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+  };
+})(), notificationTimeFields.NotificationBackendBridgeSetReminderPayload);
+var assertNotificationBackendBridgeListNoticesResult = withStrictTimes("listNotices result", /* @__PURE__ */ (() => {
+  const _ae0 = '{ readonly kind: "advertising" | "night"; readonly state: "granted" | "withdrawn"; readonly at: IsoDateTime; readonly textVersion?: NonEmptyString; }';
+  const _ae1 = '("consent-result.advertising.granted" | "consent-result.advertising.refused" | "consent-result.advertising.withdrawn" | "consent-result.night.granted" | "consent-result.night.refused" | "consent-result.night.withdrawn" | "reconfirmation.advertising" | "reconfirmation.night")';
+  const _ao0 = (input, _path, _exceptionable = true) => ((Array.isArray(input.notices) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".notices",
+    expected: "ReadonlyArray<NotificationNotice>",
+    value: input.notices
+  }, _errorFactory)) && input.notices.every((elem, _index2) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".notices[" + _index2 + "]",
+    expected: "NotificationNotice",
+    value: elem
+  }, _errorFactory)) && _ao1(elem, _path + ".notices[" + _index2 + "]", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".notices[" + _index2 + "]",
+    expected: "NotificationNotice",
+    value: elem
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".notices",
+    expected: "ReadonlyArray<NotificationNotice>",
+    value: input.notices
+  }, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["notices"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao1 = (input, _path, _exceptionable = true) => ("consent-result" === input.kind || "reconfirmation" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '("consent-result" | "reconfirmation")',
+    value: input.kind
+  }, _errorFactory)) && (("object" === typeof input.record && null !== input.record || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".record",
+    expected: _ae0,
+    value: input.record
+  }, _errorFactory)) && _ao2(input.record, _path + ".record", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
     method: "typia.createAssertEquals",
     path: _path + ".record",
     expected: _ae0,
@@ -5331,7 +7318,7 @@ var assertNotificationNotice = withStrictTimes("notice", /* @__PURE__ */ (() =>
       value
     }, _errorFactory);
   })));
-  const _ao1 = (input, _path, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+  const _ao2 = (input, _path, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
     method: "typia.createAssertEquals",
     path: _path + ".kind",
     expected: '("advertising" | "night")',
@@ -5374,7 +7361,15 @@ var assertNotificationNotice = withStrictTimes("notice", /* @__PURE__ */ (() =>
       value
     }, _errorFactory);
   })));
-  const _io0 = (input, _exceptionable = true) => ("consent-result" === input.kind || "reconfirmation" === input.kind) && ("object" === typeof input.record && null !== input.record && _io1(input.record, _exceptionable)) && ("string" === typeof input.dueBy && _isFormatDate_1._isFormatDate(input.dueBy)) && ("consent-result.advertising.granted" === input.variant || "consent-result.advertising.refused" === input.variant || "consent-result.advertising.withdrawn" === input.variant || "consent-result.night.granted" === input.variant || "consent-result.night.refused" === input.variant || "consent-result.night.withdrawn" === input.variant || "reconfirmation.advertising" === input.variant || "reconfirmation.night" === input.variant) && (4 === Object.keys(input).length || Object.keys(input).every((key) => {
+  const _io0 = (input, _exceptionable = true) => Array.isArray(input.notices) && input.notices.every((elem, _index1) => "object" === typeof elem && null !== elem && _io1(elem, _exceptionable)) && (1 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["notices"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io1 = (input, _exceptionable = true) => ("consent-result" === input.kind || "reconfirmation" === input.kind) && ("object" === typeof input.record && null !== input.record && _io2(input.record, _exceptionable)) && ("string" === typeof input.dueBy && _isFormatDate_1._isFormatDate(input.dueBy)) && ("consent-result.advertising.granted" === input.variant || "consent-result.advertising.refused" === input.variant || "consent-result.advertising.withdrawn" === input.variant || "consent-result.night.granted" === input.variant || "consent-result.night.refused" === input.variant || "consent-result.night.withdrawn" === input.variant || "reconfirmation.advertising" === input.variant || "reconfirmation.night" === input.variant) && (4 === Object.keys(input).length || Object.keys(input).every((key) => {
     if (["kind", "record", "dueBy", "variant"].some((prop) => key === prop))
       return true;
     const value = input[key];
@@ -5382,7 +7377,7 @@ var assertNotificationNotice = withStrictTimes("notice", /* @__PURE__ */ (() =>
       return true;
     return false;
   }));
-  const _io1 = (input, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind) && ("granted" === input.state || "withdrawn" === input.state) && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (void 0 === input.textVersion || "string" === typeof input.textVersion && 1 <= input.textVersion.length) && (3 === Object.keys(input).length || Object.keys(input).every((key) => {
+  const _io2 = (input, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind) && ("granted" === input.state || "withdrawn" === input.state) && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (void 0 === input.textVersion || "string" === typeof input.textVersion && 1 <= input.textVersion.length) && (3 === Object.keys(input).length || Object.keys(input).every((key) => {
     if (["kind", "state", "at", "textVersion"].some((prop) => key === prop))
       return true;
     const value = input[key];
@@ -5398,96 +7393,46 @@ var assertNotificationNotice = withStrictTimes("notice", /* @__PURE__ */ (() =>
       ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_1._assertGuard(true, {
         method: "typia.createAssertEquals",
         path: _path + "",
-        expected: "NotificationNotice",
+        expected: "NotificationBackendBridgeListNoticesResult",
         value: input2
       }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_1._assertGuard(true, {
         method: "typia.createAssertEquals",
         path: _path + "",
-        expected: "NotificationNotice",
+        expected: "NotificationBackendBridgeListNoticesResult",
         value: input2
       }, _errorFactory))(input, "$input", true);
     }
     return input;
   };
-})(), notificationTimeFields.NotificationNotice);
-var assertRecordNotificationNoticeInput = withStrictTimes("notice to record", /* @__PURE__ */ (() => {
-  const _ae0 = '{ readonly kind: "advertising" | "night"; readonly state: "granted" | "withdrawn"; readonly at: IsoDateTime; readonly textVersion?: NonEmptyString; }';
-  const _ae1 = '("consent-result.advertising.granted" | "consent-result.advertising.refused" | "consent-result.advertising.withdrawn" | "consent-result.night.granted" | "consent-result.night.refused" | "consent-result.night.withdrawn" | "reconfirmation.advertising" | "reconfirmation.night")';
-  const _ao0 = (input, _path, _exceptionable = true) => ("consent-result" === input.kind || "reconfirmation" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
-    method: "typia.createAssertEquals",
-    path: _path + ".kind",
-    expected: '("consent-result" | "reconfirmation")',
-    value: input.kind
-  }, _errorFactory)) && (("object" === typeof input.record && null !== input.record || _assertGuard_1._assertGuard(_exceptionable, {
-    method: "typia.createAssertEquals",
-    path: _path + ".record",
-    expected: _ae0,
-    value: input.record
-  }, _errorFactory)) && _ao1(input.record, _path + ".record", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+})(), notificationTimeFields.NotificationBackendBridgeListNoticesResult);
+var assertNotificationBackendBridgeRecordNoticePayload = withStrictTimes("recordNotice payload", /* @__PURE__ */ (() => {
+  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.expectedPlayer && (1 <= input.expectedPlayer.length || _assertGuard_1._assertGuard(_exceptionable, {
     method: "typia.createAssertEquals",
-    path: _path + ".record",
-    expected: _ae0,
-    value: input.record
-  }, _errorFactory)) && ("string" === typeof input.dueBy && (_isFormatDate_1._isFormatDate(input.dueBy) || _assertGuard_1._assertGuard(_exceptionable, {
-    method: "typia.createAssertEquals",
-    path: _path + ".dueBy",
-    expected: 'string & Format<"date">',
-    value: input.dueBy
+    path: _path + ".expectedPlayer",
+    expected: "string & MinLength<1>",
+    value: input.expectedPlayer
   }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
     method: "typia.createAssertEquals",
-    path: _path + ".dueBy",
-    expected: '(string & Format<"date">)',
-    value: input.dueBy
-  }, _errorFactory)) && ("consent-result.advertising.granted" === input.variant || "consent-result.advertising.refused" === input.variant || "consent-result.advertising.withdrawn" === input.variant || "consent-result.night.granted" === input.variant || "consent-result.night.refused" === input.variant || "consent-result.night.withdrawn" === input.variant || "reconfirmation.advertising" === input.variant || "reconfirmation.night" === input.variant || _assertGuard_1._assertGuard(_exceptionable, {
-    method: "typia.createAssertEquals",
-    path: _path + ".variant",
-    expected: _ae1,
-    value: input.variant
-  }, _errorFactory)) && (4 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
-    if (["kind", "record", "dueBy", "variant"].some((prop) => key === prop))
-      return true;
-    const value = input[key];
-    if (void 0 === value)
-      return true;
-    return _assertGuard_1._assertGuard(_exceptionable, {
-      method: "typia.createAssertEquals",
-      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
-      expected: "undefined",
-      value
-    }, _errorFactory);
-  })));
-  const _ao1 = (input, _path, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
-    method: "typia.createAssertEquals",
-    path: _path + ".kind",
-    expected: '("advertising" | "night")',
-    value: input.kind
-  }, _errorFactory)) && ("granted" === input.state || "withdrawn" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
-    method: "typia.createAssertEquals",
-    path: _path + ".state",
-    expected: '("granted" | "withdrawn")',
-    value: input.state
-  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
-    method: "typia.createAssertEquals",
-    path: _path + ".at",
-    expected: 'string & Format<"date-time">',
-    value: input.at
-  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    path: _path + ".expectedPlayer",
+    expected: "(string & MinLength<1>)",
+    value: input.expectedPlayer
+  }, _errorFactory)) && (("object" === typeof input.notice && null !== input.notice || _assertGuard_1._assertGuard(_exceptionable, {
     method: "typia.createAssertEquals",
-    path: _path + ".at",
-    expected: '(string & Format<"date-time">)',
-    value: input.at
-  }, _errorFactory)) && (void 0 === input.textVersion || "string" === typeof input.textVersion && (1 <= input.textVersion.length || _assertGuard_1._assertGuard(_exceptionable, {
+    path: _path + ".notice",
+    expected: "NotificationNoticeIdentity",
+    value: input.notice
+  }, _errorFactory)) && _ao1(input.notice, _path + ".notice", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
     method: "typia.createAssertEquals",
-    path: _path + ".textVersion",
-    expected: "string & MinLength<1>",
-    value: input.textVersion
-  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    path: _path + ".notice",
+    expected: "NotificationNoticeIdentity",
+    value: input.notice
+  }, _errorFactory)) && ("in-game" === input.channel || _assertGuard_1._assertGuard(_exceptionable, {
     method: "typia.createAssertEquals",
-    path: _path + ".textVersion",
-    expected: "((string & MinLength<1>) | undefined)",
-    value: input.textVersion
+    path: _path + ".channel",
+    expected: '"in-game"',
+    value: input.channel
   }, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
-    if (["kind", "state", "at", "textVersion"].some((prop) => key === prop))
+    if (["expectedPlayer", "notice", "channel"].some((prop) => key === prop))
       return true;
     const value = input[key];
     if (void 0 === value)
@@ -5499,7 +7444,7 @@ var assertRecordNotificationNoticeInput = withStrictTimes("notice to record", /*
       value
     }, _errorFactory);
   })));
-  const _ao2 = (input, _path, _exceptionable = true) => ("consent-result" === input.kind || "reconfirmation" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+  const _ao1 = (input, _path, _exceptionable = true) => ("consent-result" === input.kind || "reconfirmation" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
     method: "typia.createAssertEquals",
     path: _path + ".kind",
     expected: '("consent-result" | "reconfirmation")',
@@ -5509,7 +7454,7 @@ var assertRecordNotificationNoticeInput = withStrictTimes("notice to record", /*
     path: _path + ".record",
     expected: '{ readonly kind: "advertising" | "night"; readonly at: IsoDateTime; }',
     value: input.record
-  }, _errorFactory)) && _ao3(input.record, _path + ".record", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao2(input.record, _path + ".record", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
     method: "typia.createAssertEquals",
     path: _path + ".record",
     expected: '{ readonly kind: "advertising" | "night"; readonly at: IsoDateTime; }',
@@ -5537,7 +7482,7 @@ var assertRecordNotificationNoticeInput = withStrictTimes("notice to record", /*
       value
     }, _errorFactory);
   })));
-  const _ao3 = (input, _path, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+  const _ao2 = (input, _path, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
     method: "typia.createAssertEquals",
     path: _path + ".kind",
     expected: '("advertising" | "night")',
@@ -5565,29 +7510,15 @@ var assertRecordNotificationNoticeInput = withStrictTimes("notice to record", /*
       value
     }, _errorFactory);
   })));
-  const _au0 = (input, _path, _exceptionable = true) => (() => {
-    if (void 0 !== input.variant)
-      return _ao0(input, _path, _exceptionable);
-    else
-      return _ao2(input, _path, _exceptionable);
-  })();
-  const _io0 = (input, _exceptionable = true) => ("consent-result" === input.kind || "reconfirmation" === input.kind) && ("object" === typeof input.record && null !== input.record && _io1(input.record, _exceptionable)) && ("string" === typeof input.dueBy && _isFormatDate_1._isFormatDate(input.dueBy)) && ("consent-result.advertising.granted" === input.variant || "consent-result.advertising.refused" === input.variant || "consent-result.advertising.withdrawn" === input.variant || "consent-result.night.granted" === input.variant || "consent-result.night.refused" === input.variant || "consent-result.night.withdrawn" === input.variant || "reconfirmation.advertising" === input.variant || "reconfirmation.night" === input.variant) && (4 === Object.keys(input).length || Object.keys(input).every((key) => {
-    if (["kind", "record", "dueBy", "variant"].some((prop) => key === prop))
-      return true;
-    const value = input[key];
-    if (void 0 === value)
-      return true;
-    return false;
-  }));
-  const _io1 = (input, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind) && ("granted" === input.state || "withdrawn" === input.state) && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (void 0 === input.textVersion || "string" === typeof input.textVersion && 1 <= input.textVersion.length) && (3 === Object.keys(input).length || Object.keys(input).every((key) => {
-    if (["kind", "state", "at", "textVersion"].some((prop) => key === prop))
+  const _io0 = (input, _exceptionable = true) => "string" === typeof input.expectedPlayer && 1 <= input.expectedPlayer.length && ("object" === typeof input.notice && null !== input.notice && _io1(input.notice, _exceptionable)) && "in-game" === input.channel && (3 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["expectedPlayer", "notice", "channel"].some((prop) => key === prop))
       return true;
     const value = input[key];
     if (void 0 === value)
       return true;
     return false;
   }));
-  const _io2 = (input, _exceptionable = true) => ("consent-result" === input.kind || "reconfirmation" === input.kind) && ("object" === typeof input.record && null !== input.record && _io3(input.record, _exceptionable)) && ("string" === typeof input.dueBy && _isFormatDate_1._isFormatDate(input.dueBy)) && (3 === Object.keys(input).length || Object.keys(input).every((key) => {
+  const _io1 = (input, _exceptionable = true) => ("consent-result" === input.kind || "reconfirmation" === input.kind) && ("object" === typeof input.record && null !== input.record && _io2(input.record, _exceptionable)) && ("string" === typeof input.dueBy && _isFormatDate_1._isFormatDate(input.dueBy)) && (3 === Object.keys(input).length || Object.keys(input).every((key) => {
     if (["kind", "record", "dueBy"].some((prop) => key === prop))
       return true;
     const value = input[key];
@@ -5595,7 +7526,7 @@ var assertRecordNotificationNoticeInput = withStrictTimes("notice to record", /*
       return true;
     return false;
   }));
-  const _io3 = (input, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind) && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (2 === Object.keys(input).length || Object.keys(input).every((key) => {
+  const _io2 = (input, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind) && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (2 === Object.keys(input).length || Object.keys(input).every((key) => {
     if (["kind", "at"].some((prop) => key === prop))
       return true;
     const value = input[key];
@@ -5603,120 +7534,6 @@ var assertRecordNotificationNoticeInput = withStrictTimes("notice to record", /*
       return true;
     return false;
   }));
-  const _iu0 = (input, _exceptionable = true) => (() => {
-    if (void 0 !== input.variant)
-      return _io0(input, _exceptionable);
-    else
-      return _io2(input, _exceptionable);
-  })();
-  const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _iu0(input, true);
-  let _errorFactory;
-  return (input, errorFactory) => {
-    if (false === __is(input)) {
-      _errorFactory = errorFactory;
-      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_1._assertGuard(true, {
-        method: "typia.createAssertEquals",
-        path: _path + "",
-        expected: "(NotificationNotice | NotificationNoticeIdentity)",
-        value: input2
-      }, _errorFactory)) && _au0(input2, _path + "", true) || _assertGuard_1._assertGuard(true, {
-        method: "typia.createAssertEquals",
-        path: _path + "",
-        expected: "(NotificationNotice | NotificationNoticeIdentity)",
-        value: input2
-      }, _errorFactory))(input, "$input", true);
-    }
-    return input;
-  };
-})(), notificationTimeFields.RecordNotificationNoticeInput);
-var assertNotificationBridgeListLocalResult = withStrictTimes("listLocal result", /* @__PURE__ */ (() => {
-  const _ao0 = (input, _path, _exceptionable = true) => ((Array.isArray(input.pending) || _assertGuard_1._assertGuard(_exceptionable, {
-    method: "typia.createAssertEquals",
-    path: _path + ".pending",
-    expected: "ReadonlyArray<LocalNotificationEntry>",
-    value: input.pending
-  }, _errorFactory)) && input.pending.every((elem, _index2) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
-    method: "typia.createAssertEquals",
-    path: _path + ".pending[" + _index2 + "]",
-    expected: "LocalNotificationEntry",
-    value: elem
-  }, _errorFactory)) && _ao1(elem, _path + ".pending[" + _index2 + "]", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
-    method: "typia.createAssertEquals",
-    path: _path + ".pending[" + _index2 + "]",
-    expected: "LocalNotificationEntry",
-    value: elem
-  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
-    method: "typia.createAssertEquals",
-    path: _path + ".pending",
-    expected: "ReadonlyArray<LocalNotificationEntry>",
-    value: input.pending
-  }, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
-    if (["pending"].some((prop) => key === prop))
-      return true;
-    const value = input[key];
-    if (void 0 === value)
-      return true;
-    return _assertGuard_1._assertGuard(_exceptionable, {
-      method: "typia.createAssertEquals",
-      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
-      expected: "undefined",
-      value
-    }, _errorFactory);
-  })));
-  const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.key && (1 <= input.key.length || _assertGuard_1._assertGuard(_exceptionable, {
-    method: "typia.createAssertEquals",
-    path: _path + ".key",
-    expected: "string & CommerceMinLength<1>",
-    value: input.key
-  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
-    method: "typia.createAssertEquals",
-    path: _path + ".key",
-    expected: "(string & CommerceMinLength<1>)",
-    value: input.key
-  }, _errorFactory)) && ("string" === typeof input.topic || _assertGuard_1._assertGuard(_exceptionable, {
-    method: "typia.createAssertEquals",
-    path: _path + ".topic",
-    expected: "string",
-    value: input.topic
-  }, _errorFactory)) && ("string" === typeof input.fireAt && (_isFormatDateTime_1._isFormatDateTime(input.fireAt) || _assertGuard_1._assertGuard(_exceptionable, {
-    method: "typia.createAssertEquals",
-    path: _path + ".fireAt",
-    expected: "string & CommerceDateTimeFormat",
-    value: input.fireAt
-  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
-    method: "typia.createAssertEquals",
-    path: _path + ".fireAt",
-    expected: "(string & CommerceDateTimeFormat)",
-    value: input.fireAt
-  }, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
-    if (["key", "topic", "fireAt"].some((prop) => key === prop))
-      return true;
-    const value = input[key];
-    if (void 0 === value)
-      return true;
-    return _assertGuard_1._assertGuard(_exceptionable, {
-      method: "typia.createAssertEquals",
-      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
-      expected: "undefined",
-      value
-    }, _errorFactory);
-  })));
-  const _io0 = (input, _exceptionable = true) => Array.isArray(input.pending) && input.pending.every((elem, _index1) => "object" === typeof elem && null !== elem && _io1(elem, _exceptionable)) && (1 === Object.keys(input).length || Object.keys(input).every((key) => {
-    if (["pending"].some((prop) => key === prop))
-      return true;
-    const value = input[key];
-    if (void 0 === value)
-      return true;
-    return false;
-  }));
-  const _io1 = (input, _exceptionable = true) => "string" === typeof input.key && 1 <= input.key.length && "string" === typeof input.topic && ("string" === typeof input.fireAt && _isFormatDateTime_1._isFormatDateTime(input.fireAt)) && (3 === Object.keys(input).length || Object.keys(input).every((key) => {
-    if (["key", "topic", "fireAt"].some((prop) => key === prop))
-      return true;
-    const value = input[key];
-    if (void 0 === value)
-      return true;
-    return false;
-  }));
   const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true);
   let _errorFactory;
   return (input, errorFactory) => {
@@ -5725,18 +7542,18 @@ var assertNotificationBridgeListLocalResult = withStrictTimes("listLocal result"
       ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_1._assertGuard(true, {
         method: "typia.createAssertEquals",
         path: _path + "",
-        expected: "NotificationBridgeListLocalResult",
+        expected: "NotificationBackendBridgeRecordNoticePayload",
         value: input2
       }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_1._assertGuard(true, {
         method: "typia.createAssertEquals",
         path: _path + "",
-        expected: "NotificationBridgeListLocalResult",
+        expected: "NotificationBackendBridgeRecordNoticePayload",
         value: input2
       }, _errorFactory))(input, "$input", true);
     }
     return input;
   };
-})(), notificationTimeFields.NotificationBridgeListLocalResult);
+})(), notificationTimeFields.NotificationBackendBridgeRecordNoticePayload);
 
 // node_modules/.cache/mpgd-native-build/packages/catalog/src/notification-topics-shape.js
 import * as _isTypeUint32_12 from "typia/lib/internal/_isTypeUint32";
@@ -6803,6 +8620,19 @@ var notificationsV2MethodList = [
 ];
 var bridgeNotificationsV2Methods = Object.freeze(notificationsV2MethodList);
 var bridgeNotificationsV2MethodSet = new Set(bridgeNotificationsV2Methods);
+var notificationsBackendMethodList = [
+  "notifications.backend.getSession",
+  "notifications.backend.recordConsent",
+  "notifications.backend.listConsent",
+  "notifications.backend.registerEndpoint",
+  "notifications.backend.unregisterEndpoint",
+  "notifications.backend.setReminder",
+  "notifications.backend.cancelReminder",
+  "notifications.backend.listNotices",
+  "notifications.backend.recordNotice"
+];
+var bridgeNotificationsBackendMethods = Object.freeze(notificationsBackendMethodList);
+var bridgeNotificationsBackendMethodSet = new Set(bridgeNotificationsBackendMethods);
 
 // node_modules/.cache/mpgd-native-build/adapters/devvit/src/catalog-products.js
 var defaultDevvitCatalogTarget = "reddit";
@@ -7021,6 +8851,16 @@ var devvitNotificationSchedulerTasks = Object.freeze({
 });
 
 // node_modules/.cache/mpgd-native-build/packages/bridge/src/notifications.js
+var notificationsBackendBridgeHostCodes = Object.freeze({
+  /** The request has no authenticated player (a logged-out Devvit viewer). */
+  signedOut: "NOTIFICATIONS_SIGNED_OUT",
+  /**
+   * The request's authenticated player is not the call's `expectedPlayer`:
+   * another player signed in since the call began. Nothing was read or
+   * changed; the client reads the session again.
+   */
+  sessionChanged: "NOTIFICATIONS_SESSION_CHANGED"
+});
 var hostCodeCharacters = "[A-Za-z0-9_.:-]{1,128}";
 var hostCodeValue = new RegExp(`^${hostCodeCharacters}$`, "u");
 var hostCodeSuffix = new RegExp(`\\(host code (${hostCodeCharacters})\\)$`, "u");
@@ -14593,6 +16433,15 @@ var commonEdits = {
   "src/platform/buildGateways/capacitorAndroid.ts": [gatewayImport, gatewayProviders("android")],
   "src/platform/buildGateways/capacitorIos.ts": [gatewayImport, gatewayProviders("ios")],
   "src/platform/buildGateways/reddit.ts": [
+    {
+      anchor: "  createDevvitCommerceProducts,\n  createDevvitPlatformGateway,\n",
+      replacement: [
+        "  createDevvitCommerceProducts,",
+        "  createDevvitNotificationsBackend,",
+        "  createDevvitPlatformGateway,",
+        ""
+      ].join("\n")
+    },
     {
       anchor: "import { createDevvitWebPaymentsClient } from '@mpgd/adapter-devvit/web';\n",
       replacement: [
@@ -14606,6 +16455,7 @@ var commonEdits = {
     {
       anchor: "import type { RuntimeConfig } from '../runtimeDetector';\n",
       replacement: [
+        "import { setStarterHostedNotificationBackend } from '../notificationBackend';",
         "import { starterNotificationTopics } from '../notifications';",
         "import type { RuntimeConfig } from '../runtimeDetector';",
         ""
@@ -14631,7 +16481,14 @@ var commonEdits = {
         "  runtime: RuntimeConfig,",
         "): Pick<Parameters<typeof createDevvitPlatformGateway>[0], 'notifications'> {",
         "  const topics = starterNotificationTopics(runtime.configTarget).map((topic) => topic.id);",
-        "  return topics.length === 0 ? {} : { notifications: { topics } };",
+        "  if (topics.length === 0) {",
+        "    return {};",
+        "  }",
+        "  // The runtime's backend is the Devvit server (consent records, reminders, notices for the",
+        "  // logged-in Reddit user), over the same server bridge as the gateway; created on first use.",
+        "  setStarterHostedNotificationBackend(runtime.configTarget, () =>",
+        "    createDevvitNotificationsBackend({ appVersion: runtime.appVersion, buildId: runtime.buildId }));",
+        "  return { notifications: { topics } };",
         "}",
         "",
         "function createCommerceOptions(): DevvitGatewayCommerceOptions | undefined {",
@@ -14668,6 +16525,7 @@ var commonEdits = {
         "  createDevvitCommerceBridgeProducts,",
         "  createDevvitCommerceV2BridgeHandler,",
         "  createDevvitNotificationService,",
+        "  createDevvitNotificationsBackendBridgeHandler,",
         "  createDevvitNotificationsV2BridgeHandler,",
         "} from '@mpgd/adapter-devvit/server';",
         ""
@@ -14711,7 +16569,7 @@ var commonEdits = {
         " */",
         "const notificationTopicCatalog = notificationTopicsJson as NotificationTopicCatalog;",
         "const redditNotificationTopics = readRedditNotificationTopics();",
-        "const notificationService: Parameters<typeof handleNotificationTask>[0]['notifications'] =",
+        "const notificationService: ReturnType<typeof createDevvitNotificationService>['service'] | undefined =",
         "  redditNotificationTopics.length === 0 ? undefined : createNotificationService();",
         "// The opt-in is served only with the service that sends; a refused catalog turns both off.",
         "const notificationsBridge = notificationService === undefined",
@@ -14721,6 +16579,10 @@ var commonEdits = {
         "      currentUserId: currentPlayerId,",
         "      topics: redditNotificationTopics,",
         "    });",
+        "// The webview runtime's backend: consent records, reminders, and notices for the request's user.",
+        "const notificationsBackend = notificationService === undefined",
+        "  ? undefined",
+        "  : createDevvitNotificationsBackendBridgeHandler({ service: notificationService, context: () => context });",
         "const handleBridgeRequest = createDevvitBridgeHandler({",
         "  redis,",
         "  currentPlayerId,",
@@ -14728,6 +16590,7 @@ var commonEdits = {
         "  storageKeyNamespace: gameName,",
         "  ...(commerce === undefined ? {} : { commerce }),",
         "  ...(notificationsBridge === undefined ? {} : { notifications: notificationsBridge }),",
+        "  ...(notificationsBackend === undefined ? {} : { notificationsBackend }),",
         "});",
         ""
       ].join("\n")
@@ -14759,7 +16622,7 @@ var commonEdits = {
         " * deployment the service refuses turns notifications off, never the game",
         " * server.",
         " */",
-        "function createNotificationService(): Parameters<typeof handleNotificationTask>[0]['notifications'] {",
+        "function createNotificationService(): ReturnType<typeof createDevvitNotificationService>['service'] | undefined {",
         "  try {",
         "    return createDevvitNotificationService({",
         "      redis,",
@@ -14900,8 +16763,16 @@ var notificationsCapacitorSupportFiles = Object.freeze([
   "docs/NOTIFICATIONS.md"
 ]);
 var notificationsCapacitorTemplateSupportFiles = Object.freeze([
-  "src/platform/serverSession.ts"
+  "src/platform/serverSession.ts",
+  "src/platform/developmentServerSession.ts"
 ]);
+var notificationsCapacitorTemplateSupportImporters = Object.freeze({
+  "src/platform/developmentServerSession.ts": {
+    importer: "src/platform/serverSession.ts",
+    requires: { packageName: "@mpgd/game-services", exportName: "createDevelopmentServerSession" },
+    warning: "src/platform/serverSession.ts predates development notification sessions (VITE_MPGD_DEV_NOTIFICATION_SESSION); to try notifications locally, copy serverSession.ts and developmentServerSession.ts from the starter template."
+  }
+});
 
 // node_modules/.cache/mpgd-native-build/packages/cli/src/native-shell-identity.js
 function assertAndroidSettingsAppProject(source) {