@keetanetwork/anchor 0.0.39 → 0.0.41

package/services/storage/common.generated.js

@@ -0,0 +1,863 @@
+import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
+import { createIs, createAssert } from 'typia';
+export const isKeetaStorageAnchorPutResponse = (() => { const _io0 = input => false === input.ok && "string" === typeof input.error; const _io1 = input => true === input.ok && ("object" === typeof input.object && null !== input.object && _io2(input.object)); const _io2 = input => "string" === typeof input.path && "string" === typeof input.owner && (Array.isArray(input.tags) && input.tags.every(elem => "string" === typeof elem)) && ("public" === input.visibility || "private" === input.visibility) && "number" === typeof input.size && "string" === typeof input.createdAt && (undefined === input.updatedAt || "string" === typeof input.updatedAt); const _iu0 = input => (() => {
+    if (false === input.ok)
+        return _io0(input);
+    else if (true === input.ok)
+        return _io1(input);
+    else
+        return false;
+})(); return input => "object" === typeof input && null !== input && _iu0(input); })();
+export const isKeetaStorageAnchorGetResponse = (() => { const _io0 = input => false === input.ok && "string" === typeof input.error; const _io1 = input => true === input.ok && "string" === typeof input.data && ("object" === typeof input.object && null !== input.object && _io2(input.object)); const _io2 = input => "string" === typeof input.path && "string" === typeof input.owner && (Array.isArray(input.tags) && input.tags.every(elem => "string" === typeof elem)) && ("public" === input.visibility || "private" === input.visibility) && "number" === typeof input.size && "string" === typeof input.createdAt && (undefined === input.updatedAt || "string" === typeof input.updatedAt); const _iu0 = input => (() => {
+    if (false === input.ok)
+        return _io0(input);
+    else if (true === input.ok)
+        return _io1(input);
+    else
+        return false;
+})(); return input => "object" === typeof input && null !== input && _iu0(input); })();
+export const isKeetaStorageAnchorDeleteResponse = (() => { const _io0 = input => false === input.ok && "string" === typeof input.error; const _io1 = input => true === input.ok && "boolean" === typeof input.deleted; const _iu0 = input => (() => {
+    if (false === input.ok)
+        return _io0(input);
+    else if (true === input.ok)
+        return _io1(input);
+    else
+        return false;
+})(); return input => "object" === typeof input && null !== input && _iu0(input); })();
+export const isKeetaStorageAnchorSearchResponse = (() => { const _io0 = input => false === input.ok && "string" === typeof input.error; const _io1 = input => true === input.ok && (Array.isArray(input.results) && input.results.every(elem => "object" === typeof elem && null !== elem && _io2(elem))) && (undefined === input.nextCursor || "string" === typeof input.nextCursor); const _io2 = input => "string" === typeof input.path && "string" === typeof input.owner && (Array.isArray(input.tags) && input.tags.every(elem => "string" === typeof elem)) && ("public" === input.visibility || "private" === input.visibility) && "number" === typeof input.size && "string" === typeof input.createdAt && (undefined === input.updatedAt || "string" === typeof input.updatedAt); const _iu0 = input => (() => {
+    if (false === input.ok)
+        return _io0(input);
+    else if (true === input.ok)
+        return _io1(input);
+    else
+        return false;
+})(); return input => "object" === typeof input && null !== input && _iu0(input); })();
+export const isKeetaStorageAnchorQuotaResponse = (() => { const _io0 = input => false === input.ok && "string" === typeof input.error; const _io1 = input => true === input.ok && ("object" === typeof input.quota && null !== input.quota && _io2(input.quota)); const _io2 = input => "number" === typeof input.objectCount && "number" === typeof input.totalSize && (undefined === input.remainingObjects || "number" === typeof input.remainingObjects) && (undefined === input.remainingSize || "number" === typeof input.remainingSize); const _iu0 = input => (() => {
+    if (false === input.ok)
+        return _io0(input);
+    else if (true === input.ok)
+        return _io1(input);
+    else
+        return false;
+})(); return input => "object" === typeof input && null !== input && _iu0(input); })();
+export const assertKeetaStorageAnchorPutRequest = (() => { const _io0 = input => (undefined === input.account || "string" === typeof input.account) && (undefined === input.signed || "object" === typeof input.signed && null !== input.signed && _io1(input.signed)) && "string" === typeof input.path && "string" === typeof input.data && (undefined === input.tags || Array.isArray(input.tags) && input.tags.every(elem => "string" === typeof elem)) && (undefined === input.visibility || "public" === input.visibility || "private" === input.visibility); const _io1 = input => "string" === typeof input.nonce && "string" === typeof input.timestamp && "string" === typeof input.signature; const _ao0 = (input, _path, _exceptionable = true) => (undefined === input.account || "string" === typeof input.account || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".account",
+    expected: "(string | undefined)",
+    value: input.account
+}, _errorFactory)) && (undefined === input.signed || ("object" === typeof input.signed && null !== input.signed || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".signed",
+    expected: "(HTTPSignedField | undefined)",
+    value: input.signed
+}, _errorFactory)) && _ao1(input.signed, _path + ".signed", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".signed",
+    expected: "(HTTPSignedField | undefined)",
+    value: input.signed
+}, _errorFactory)) && ("string" === typeof input.path || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".path",
+    expected: "string",
+    value: input.path
+}, _errorFactory)) && ("string" === typeof input.data || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".data",
+    expected: "string",
+    value: input.data
+}, _errorFactory)) && (undefined === input.tags || (Array.isArray(input.tags) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".tags",
+    expected: "(Array<string> | undefined)",
+    value: input.tags
+}, _errorFactory)) && input.tags.every((elem, _index2) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".tags[" + _index2 + "]",
+    expected: "string",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".tags",
+    expected: "(Array<string> | undefined)",
+    value: input.tags
+}, _errorFactory)) && (undefined === input.visibility || "public" === input.visibility || "private" === input.visibility || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".visibility",
+    expected: "(\"private\" | \"public\" | undefined)",
+    value: input.visibility
+}, _errorFactory)); const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.nonce || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".nonce",
+    expected: "string",
+    value: input.nonce
+}, _errorFactory)) && ("string" === typeof input.timestamp || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".timestamp",
+    expected: "string",
+    value: input.timestamp
+}, _errorFactory)) && ("string" === typeof input.signature || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".signature",
+    expected: "string",
+    value: input.signature
+}, _errorFactory)); const __is = input => "object" === typeof input && null !== input && _io0(input); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "KeetaStorageAnchorPutRequest",
+            value: input
+        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "KeetaStorageAnchorPutRequest",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+export const assertKeetaStorageAnchorPutResponse = (() => { const _io0 = input => false === input.ok && "string" === typeof input.error; const _io1 = input => true === input.ok && ("object" === typeof input.object && null !== input.object && _io2(input.object)); const _io2 = input => "string" === typeof input.path && "string" === typeof input.owner && (Array.isArray(input.tags) && input.tags.every(elem => "string" === typeof elem)) && ("public" === input.visibility || "private" === input.visibility) && "number" === typeof input.size && "string" === typeof input.createdAt && (undefined === input.updatedAt || "string" === typeof input.updatedAt); const _iu0 = input => (() => {
+    if (false === input.ok)
+        return _io0(input);
+    else if (true === input.ok)
+        return _io1(input);
+    else
+        return false;
+})(); const _ao0 = (input, _path, _exceptionable = true) => (false === input.ok || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".ok",
+    expected: "false",
+    value: input.ok
+}, _errorFactory)) && ("string" === typeof input.error || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".error",
+    expected: "string",
+    value: input.error
+}, _errorFactory)); const _ao1 = (input, _path, _exceptionable = true) => (true === input.ok || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".ok",
+    expected: "true",
+    value: input.ok
+}, _errorFactory)) && (("object" === typeof input.object && null !== input.object || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".object",
+    expected: "StorageObjectMetadata",
+    value: input.object
+}, _errorFactory)) && _ao2(input.object, _path + ".object", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".object",
+    expected: "StorageObjectMetadata",
+    value: input.object
+}, _errorFactory)); const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.path || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".path",
+    expected: "string",
+    value: input.path
+}, _errorFactory)) && ("string" === typeof input.owner || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".owner",
+    expected: "string",
+    value: input.owner
+}, _errorFactory)) && ((Array.isArray(input.tags) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".tags",
+    expected: "Array<string>",
+    value: input.tags
+}, _errorFactory)) && input.tags.every((elem, _index2) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".tags[" + _index2 + "]",
+    expected: "string",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".tags",
+    expected: "Array<string>",
+    value: input.tags
+}, _errorFactory)) && ("public" === input.visibility || "private" === input.visibility || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".visibility",
+    expected: "(\"private\" | \"public\")",
+    value: input.visibility
+}, _errorFactory)) && ("number" === typeof input.size || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".size",
+    expected: "number",
+    value: input.size
+}, _errorFactory)) && ("string" === typeof input.createdAt || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".createdAt",
+    expected: "string",
+    value: input.createdAt
+}, _errorFactory)) && (undefined === input.updatedAt || "string" === typeof input.updatedAt || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".updatedAt",
+    expected: "(string | undefined)",
+    value: input.updatedAt
+}, _errorFactory)); const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if (false === input.ok)
+        return _ao0(input, _path, true && _exceptionable);
+    else if (true === input.ok)
+        return _ao1(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssert",
+            path: _path,
+            expected: "(__type | { ok: true; } & { object: StorageObjectMetadata; })",
+            value: input
+        }, _errorFactory);
+})(); const __is = input => "object" === typeof input && null !== input && _iu0(input); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "(__type | { ok: true; } & { object: StorageObjectMetadata; })",
+            value: input
+        }, _errorFactory)) && _au0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "(__type | { ok: true; } & { object: StorageObjectMetadata; })",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+export const assertKeetaStorageAnchorGetRequest = (() => { const _io0 = input => (undefined === input.account || "string" === typeof input.account) && (undefined === input.signed || "object" === typeof input.signed && null !== input.signed && _io1(input.signed)) && "string" === typeof input.path; const _io1 = input => "string" === typeof input.nonce && "string" === typeof input.timestamp && "string" === typeof input.signature; const _ao0 = (input, _path, _exceptionable = true) => (undefined === input.account || "string" === typeof input.account || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".account",
+    expected: "(string | undefined)",
+    value: input.account
+}, _errorFactory)) && (undefined === input.signed || ("object" === typeof input.signed && null !== input.signed || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".signed",
+    expected: "(HTTPSignedField | undefined)",
+    value: input.signed
+}, _errorFactory)) && _ao1(input.signed, _path + ".signed", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".signed",
+    expected: "(HTTPSignedField | undefined)",
+    value: input.signed
+}, _errorFactory)) && ("string" === typeof input.path || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".path",
+    expected: "string",
+    value: input.path
+}, _errorFactory)); const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.nonce || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".nonce",
+    expected: "string",
+    value: input.nonce
+}, _errorFactory)) && ("string" === typeof input.timestamp || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".timestamp",
+    expected: "string",
+    value: input.timestamp
+}, _errorFactory)) && ("string" === typeof input.signature || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".signature",
+    expected: "string",
+    value: input.signature
+}, _errorFactory)); const __is = input => "object" === typeof input && null !== input && _io0(input); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "KeetaStorageAnchorGetRequest",
+            value: input
+        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "KeetaStorageAnchorGetRequest",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+export const assertKeetaStorageAnchorGetResponse = (() => { const _io0 = input => false === input.ok && "string" === typeof input.error; const _io1 = input => true === input.ok && "string" === typeof input.data && ("object" === typeof input.object && null !== input.object && _io2(input.object)); const _io2 = input => "string" === typeof input.path && "string" === typeof input.owner && (Array.isArray(input.tags) && input.tags.every(elem => "string" === typeof elem)) && ("public" === input.visibility || "private" === input.visibility) && "number" === typeof input.size && "string" === typeof input.createdAt && (undefined === input.updatedAt || "string" === typeof input.updatedAt); const _iu0 = input => (() => {
+    if (false === input.ok)
+        return _io0(input);
+    else if (true === input.ok)
+        return _io1(input);
+    else
+        return false;
+})(); const _ao0 = (input, _path, _exceptionable = true) => (false === input.ok || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".ok",
+    expected: "false",
+    value: input.ok
+}, _errorFactory)) && ("string" === typeof input.error || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".error",
+    expected: "string",
+    value: input.error
+}, _errorFactory)); const _ao1 = (input, _path, _exceptionable = true) => (true === input.ok || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".ok",
+    expected: "true",
+    value: input.ok
+}, _errorFactory)) && ("string" === typeof input.data || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".data",
+    expected: "string",
+    value: input.data
+}, _errorFactory)) && (("object" === typeof input.object && null !== input.object || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".object",
+    expected: "StorageObjectMetadata",
+    value: input.object
+}, _errorFactory)) && _ao2(input.object, _path + ".object", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".object",
+    expected: "StorageObjectMetadata",
+    value: input.object
+}, _errorFactory)); const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.path || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".path",
+    expected: "string",
+    value: input.path
+}, _errorFactory)) && ("string" === typeof input.owner || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".owner",
+    expected: "string",
+    value: input.owner
+}, _errorFactory)) && ((Array.isArray(input.tags) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".tags",
+    expected: "Array<string>",
+    value: input.tags
+}, _errorFactory)) && input.tags.every((elem, _index2) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".tags[" + _index2 + "]",
+    expected: "string",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".tags",
+    expected: "Array<string>",
+    value: input.tags
+}, _errorFactory)) && ("public" === input.visibility || "private" === input.visibility || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".visibility",
+    expected: "(\"private\" | \"public\")",
+    value: input.visibility
+}, _errorFactory)) && ("number" === typeof input.size || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".size",
+    expected: "number",
+    value: input.size
+}, _errorFactory)) && ("string" === typeof input.createdAt || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".createdAt",
+    expected: "string",
+    value: input.createdAt
+}, _errorFactory)) && (undefined === input.updatedAt || "string" === typeof input.updatedAt || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".updatedAt",
+    expected: "(string | undefined)",
+    value: input.updatedAt
+}, _errorFactory)); const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if (false === input.ok)
+        return _ao0(input, _path, true && _exceptionable);
+    else if (true === input.ok)
+        return _ao1(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssert",
+            path: _path,
+            expected: "(__type | { ok: true; } & { data: string; object: StorageObjectMetadata; })",
+            value: input
+        }, _errorFactory);
+})(); const __is = input => "object" === typeof input && null !== input && _iu0(input); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "(__type | { ok: true; } & { data: string; object: StorageObjectMetadata; })",
+            value: input
+        }, _errorFactory)) && _au0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "(__type | { ok: true; } & { data: string; object: StorageObjectMetadata; })",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+export const assertKeetaStorageAnchorDeleteRequest = (() => { const _io0 = input => (undefined === input.account || "string" === typeof input.account) && (undefined === input.signed || "object" === typeof input.signed && null !== input.signed && _io1(input.signed)) && "string" === typeof input.path; const _io1 = input => "string" === typeof input.nonce && "string" === typeof input.timestamp && "string" === typeof input.signature; const _ao0 = (input, _path, _exceptionable = true) => (undefined === input.account || "string" === typeof input.account || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".account",
+    expected: "(string | undefined)",
+    value: input.account
+}, _errorFactory)) && (undefined === input.signed || ("object" === typeof input.signed && null !== input.signed || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".signed",
+    expected: "(HTTPSignedField | undefined)",
+    value: input.signed
+}, _errorFactory)) && _ao1(input.signed, _path + ".signed", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".signed",
+    expected: "(HTTPSignedField | undefined)",
+    value: input.signed
+}, _errorFactory)) && ("string" === typeof input.path || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".path",
+    expected: "string",
+    value: input.path
+}, _errorFactory)); const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.nonce || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".nonce",
+    expected: "string",
+    value: input.nonce
+}, _errorFactory)) && ("string" === typeof input.timestamp || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".timestamp",
+    expected: "string",
+    value: input.timestamp
+}, _errorFactory)) && ("string" === typeof input.signature || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".signature",
+    expected: "string",
+    value: input.signature
+}, _errorFactory)); const __is = input => "object" === typeof input && null !== input && _io0(input); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "KeetaStorageAnchorDeleteRequest",
+            value: input
+        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "KeetaStorageAnchorDeleteRequest",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+export const assertKeetaStorageAnchorDeleteResponse = (() => { const _io0 = input => false === input.ok && "string" === typeof input.error; const _io1 = input => true === input.ok && "boolean" === typeof input.deleted; const _iu0 = input => (() => {
+    if (false === input.ok)
+        return _io0(input);
+    else if (true === input.ok)
+        return _io1(input);
+    else
+        return false;
+})(); const _ao0 = (input, _path, _exceptionable = true) => (false === input.ok || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".ok",
+    expected: "false",
+    value: input.ok
+}, _errorFactory)) && ("string" === typeof input.error || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".error",
+    expected: "string",
+    value: input.error
+}, _errorFactory)); const _ao1 = (input, _path, _exceptionable = true) => (true === input.ok || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".ok",
+    expected: "true",
+    value: input.ok
+}, _errorFactory)) && ("boolean" === typeof input.deleted || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".deleted",
+    expected: "boolean",
+    value: input.deleted
+}, _errorFactory)); const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if (false === input.ok)
+        return _ao0(input, _path, true && _exceptionable);
+    else if (true === input.ok)
+        return _ao1(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssert",
+            path: _path,
+            expected: "(__type | { ok: true; } & { deleted: boolean; })",
+            value: input
+        }, _errorFactory);
+})(); const __is = input => "object" === typeof input && null !== input && _iu0(input); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "(__type | { ok: true; } & { deleted: boolean; })",
+            value: input
+        }, _errorFactory)) && _au0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "(__type | { ok: true; } & { deleted: boolean; })",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+export const assertKeetaStorageAnchorSearchRequest = (() => { const _io0 = input => (undefined === input.account || "string" === typeof input.account) && (undefined === input.signed || "object" === typeof input.signed && null !== input.signed && _io1(input.signed)) && ("object" === typeof input.criteria && null !== input.criteria && false === Array.isArray(input.criteria) && _io2(input.criteria)) && (undefined === input.pagination || "object" === typeof input.pagination && null !== input.pagination && false === Array.isArray(input.pagination) && _io3(input.pagination)); const _io1 = input => "string" === typeof input.nonce && "string" === typeof input.timestamp && "string" === typeof input.signature; const _io2 = input => (undefined === input.pathPrefix || "string" === typeof input.pathPrefix) && (undefined === input.tags || Array.isArray(input.tags) && input.tags.every(elem => "string" === typeof elem)) && (undefined === input.name || "string" === typeof input.name) && (undefined === input.owner || "string" === typeof input.owner) && (undefined === input.recursive || "boolean" === typeof input.recursive) && (undefined === input.visibility || "public" === input.visibility || "private" === input.visibility); const _io3 = input => (undefined === input.cursor || "string" === typeof input.cursor) && (undefined === input.limit || "number" === typeof input.limit); const _ao0 = (input, _path, _exceptionable = true) => (undefined === input.account || "string" === typeof input.account || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".account",
+    expected: "(string | undefined)",
+    value: input.account
+}, _errorFactory)) && (undefined === input.signed || ("object" === typeof input.signed && null !== input.signed || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".signed",
+    expected: "(HTTPSignedField | undefined)",
+    value: input.signed
+}, _errorFactory)) && _ao1(input.signed, _path + ".signed", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".signed",
+    expected: "(HTTPSignedField | undefined)",
+    value: input.signed
+}, _errorFactory)) && (("object" === typeof input.criteria && null !== input.criteria && false === Array.isArray(input.criteria) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".criteria",
+    expected: "SearchCriteria",
+    value: input.criteria
+}, _errorFactory)) && _ao2(input.criteria, _path + ".criteria", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".criteria",
+    expected: "SearchCriteria",
+    value: input.criteria
+}, _errorFactory)) && (undefined === input.pagination || ("object" === typeof input.pagination && null !== input.pagination && false === Array.isArray(input.pagination) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".pagination",
+    expected: "(SearchPagination | undefined)",
+    value: input.pagination
+}, _errorFactory)) && _ao3(input.pagination, _path + ".pagination", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".pagination",
+    expected: "(SearchPagination | undefined)",
+    value: input.pagination
+}, _errorFactory)); const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.nonce || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".nonce",
+    expected: "string",
+    value: input.nonce
+}, _errorFactory)) && ("string" === typeof input.timestamp || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".timestamp",
+    expected: "string",
+    value: input.timestamp
+}, _errorFactory)) && ("string" === typeof input.signature || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".signature",
+    expected: "string",
+    value: input.signature
+}, _errorFactory)); const _ao2 = (input, _path, _exceptionable = true) => (undefined === input.pathPrefix || "string" === typeof input.pathPrefix || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".pathPrefix",
+    expected: "(string | undefined)",
+    value: input.pathPrefix
+}, _errorFactory)) && (undefined === input.tags || (Array.isArray(input.tags) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".tags",
+    expected: "(Array<string> | undefined)",
+    value: input.tags
+}, _errorFactory)) && input.tags.every((elem, _index2) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".tags[" + _index2 + "]",
+    expected: "string",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".tags",
+    expected: "(Array<string> | undefined)",
+    value: input.tags
+}, _errorFactory)) && (undefined === input.name || "string" === typeof input.name || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".name",
+    expected: "(string | undefined)",
+    value: input.name
+}, _errorFactory)) && (undefined === input.owner || "string" === typeof input.owner || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".owner",
+    expected: "(string | undefined)",
+    value: input.owner
+}, _errorFactory)) && (undefined === input.recursive || "boolean" === typeof input.recursive || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".recursive",
+    expected: "(boolean | undefined)",
+    value: input.recursive
+}, _errorFactory)) && (undefined === input.visibility || "public" === input.visibility || "private" === input.visibility || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".visibility",
+    expected: "(\"private\" | \"public\" | undefined)",
+    value: input.visibility
+}, _errorFactory)); const _ao3 = (input, _path, _exceptionable = true) => (undefined === input.cursor || "string" === typeof input.cursor || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".cursor",
+    expected: "(string | undefined)",
+    value: input.cursor
+}, _errorFactory)) && (undefined === input.limit || "number" === typeof input.limit || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".limit",
+    expected: "(number | undefined)",
+    value: input.limit
+}, _errorFactory)); const __is = input => "object" === typeof input && null !== input && _io0(input); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "KeetaStorageAnchorSearchRequest",
+            value: input
+        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "KeetaStorageAnchorSearchRequest",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+export const assertKeetaStorageAnchorSearchResponse = (() => { const _io0 = input => false === input.ok && "string" === typeof input.error; const _io1 = input => true === input.ok && (Array.isArray(input.results) && input.results.every(elem => "object" === typeof elem && null !== elem && _io2(elem))) && (undefined === input.nextCursor || "string" === typeof input.nextCursor); const _io2 = input => "string" === typeof input.path && "string" === typeof input.owner && (Array.isArray(input.tags) && input.tags.every(elem => "string" === typeof elem)) && ("public" === input.visibility || "private" === input.visibility) && "number" === typeof input.size && "string" === typeof input.createdAt && (undefined === input.updatedAt || "string" === typeof input.updatedAt); const _iu0 = input => (() => {
+    if (false === input.ok)
+        return _io0(input);
+    else if (true === input.ok)
+        return _io1(input);
+    else
+        return false;
+})(); const _ao0 = (input, _path, _exceptionable = true) => (false === input.ok || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".ok",
+    expected: "false",
+    value: input.ok
+}, _errorFactory)) && ("string" === typeof input.error || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".error",
+    expected: "string",
+    value: input.error
+}, _errorFactory)); const _ao1 = (input, _path, _exceptionable = true) => (true === input.ok || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".ok",
+    expected: "true",
+    value: input.ok
+}, _errorFactory)) && ((Array.isArray(input.results) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".results",
+    expected: "Array<StorageObjectMetadata>",
+    value: input.results
+}, _errorFactory)) && input.results.every((elem, _index3) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".results[" + _index3 + "]",
+    expected: "StorageObjectMetadata",
+    value: elem
+}, _errorFactory)) && _ao2(elem, _path + ".results[" + _index3 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".results[" + _index3 + "]",
+    expected: "StorageObjectMetadata",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".results",
+    expected: "Array<StorageObjectMetadata>",
+    value: input.results
+}, _errorFactory)) && (undefined === input.nextCursor || "string" === typeof input.nextCursor || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".nextCursor",
+    expected: "(string | undefined)",
+    value: input.nextCursor
+}, _errorFactory)); const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.path || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".path",
+    expected: "string",
+    value: input.path
+}, _errorFactory)) && ("string" === typeof input.owner || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".owner",
+    expected: "string",
+    value: input.owner
+}, _errorFactory)) && ((Array.isArray(input.tags) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".tags",
+    expected: "Array<string>",
+    value: input.tags
+}, _errorFactory)) && input.tags.every((elem, _index4) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".tags[" + _index4 + "]",
+    expected: "string",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".tags",
+    expected: "Array<string>",
+    value: input.tags
+}, _errorFactory)) && ("public" === input.visibility || "private" === input.visibility || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".visibility",
+    expected: "(\"private\" | \"public\")",
+    value: input.visibility
+}, _errorFactory)) && ("number" === typeof input.size || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".size",
+    expected: "number",
+    value: input.size
+}, _errorFactory)) && ("string" === typeof input.createdAt || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".createdAt",
+    expected: "string",
+    value: input.createdAt
+}, _errorFactory)) && (undefined === input.updatedAt || "string" === typeof input.updatedAt || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".updatedAt",
+    expected: "(string | undefined)",
+    value: input.updatedAt
+}, _errorFactory)); const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if (false === input.ok)
+        return _ao0(input, _path, true && _exceptionable);
+    else if (true === input.ok)
+        return _ao1(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssert",
+            path: _path,
+            expected: "(__type | { ok: true; } & { results: StorageObjectMetadata[]; nextCursor?: string; })",
+            value: input
+        }, _errorFactory);
+})(); const __is = input => "object" === typeof input && null !== input && _iu0(input); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "(__type | { ok: true; } & { results: StorageObjectMetadata[]; nextCursor?: string; })",
+            value: input
+        }, _errorFactory)) && _au0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "(__type | { ok: true; } & { results: StorageObjectMetadata[]; nextCursor?: string; })",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+export const assertKeetaStorageAnchorQuotaRequest = (() => { const _io0 = input => (undefined === input.account || "string" === typeof input.account) && (undefined === input.signed || "object" === typeof input.signed && null !== input.signed && _io1(input.signed)); const _io1 = input => "string" === typeof input.nonce && "string" === typeof input.timestamp && "string" === typeof input.signature; const _ao0 = (input, _path, _exceptionable = true) => (undefined === input.account || "string" === typeof input.account || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".account",
+    expected: "(string | undefined)",
+    value: input.account
+}, _errorFactory)) && (undefined === input.signed || ("object" === typeof input.signed && null !== input.signed || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".signed",
+    expected: "(HTTPSignedField | undefined)",
+    value: input.signed
+}, _errorFactory)) && _ao1(input.signed, _path + ".signed", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".signed",
+    expected: "(HTTPSignedField | undefined)",
+    value: input.signed
+}, _errorFactory)); const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.nonce || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".nonce",
+    expected: "string",
+    value: input.nonce
+}, _errorFactory)) && ("string" === typeof input.timestamp || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".timestamp",
+    expected: "string",
+    value: input.timestamp
+}, _errorFactory)) && ("string" === typeof input.signature || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".signature",
+    expected: "string",
+    value: input.signature
+}, _errorFactory)); const __is = input => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input && false === Array.isArray(input) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "KeetaStorageAnchorQuotaRequest",
+            value: input
+        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "KeetaStorageAnchorQuotaRequest",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+export const assertKeetaStorageAnchorQuotaResponse = (() => { const _io0 = input => false === input.ok && "string" === typeof input.error; const _io1 = input => true === input.ok && ("object" === typeof input.quota && null !== input.quota && _io2(input.quota)); const _io2 = input => "number" === typeof input.objectCount && "number" === typeof input.totalSize && (undefined === input.remainingObjects || "number" === typeof input.remainingObjects) && (undefined === input.remainingSize || "number" === typeof input.remainingSize); const _iu0 = input => (() => {
+    if (false === input.ok)
+        return _io0(input);
+    else if (true === input.ok)
+        return _io1(input);
+    else
+        return false;
+})(); const _ao0 = (input, _path, _exceptionable = true) => (false === input.ok || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".ok",
+    expected: "false",
+    value: input.ok
+}, _errorFactory)) && ("string" === typeof input.error || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".error",
+    expected: "string",
+    value: input.error
+}, _errorFactory)); const _ao1 = (input, _path, _exceptionable = true) => (true === input.ok || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".ok",
+    expected: "true",
+    value: input.ok
+}, _errorFactory)) && (("object" === typeof input.quota && null !== input.quota || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".quota",
+    expected: "QuotaStatus",
+    value: input.quota
+}, _errorFactory)) && _ao2(input.quota, _path + ".quota", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".quota",
+    expected: "QuotaStatus",
+    value: input.quota
+}, _errorFactory)); const _ao2 = (input, _path, _exceptionable = true) => ("number" === typeof input.objectCount || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".objectCount",
+    expected: "number",
+    value: input.objectCount
+}, _errorFactory)) && ("number" === typeof input.totalSize || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".totalSize",
+    expected: "number",
+    value: input.totalSize
+}, _errorFactory)) && (undefined === input.remainingObjects || "number" === typeof input.remainingObjects || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".remainingObjects",
+    expected: "(number | undefined)",
+    value: input.remainingObjects
+}, _errorFactory)) && (undefined === input.remainingSize || "number" === typeof input.remainingSize || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".remainingSize",
+    expected: "(number | undefined)",
+    value: input.remainingSize
+}, _errorFactory)); const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if (false === input.ok)
+        return _ao0(input, _path, true && _exceptionable);
+    else if (true === input.ok)
+        return _ao1(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssert",
+            path: _path,
+            expected: "(__type | { ok: true; } & { quota: QuotaStatus; })",
+            value: input
+        }, _errorFactory);
+})(); const __is = input => "object" === typeof input && null !== input && _iu0(input); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "(__type | { ok: true; } & { quota: QuotaStatus; })",
+            value: input
+        }, _errorFactory)) && _au0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "(__type | { ok: true; } & { quota: QuotaStatus; })",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+//# sourceMappingURL=common.generated.js.map