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;
}; })();
export const assertKeetaStorageAnchorUpdateMetadataRequest = (() => { const _io0 = input => (undefined === input.account || "string" === typeof input.account) && (undefined === input.signed || "object" === typeof input.signed && null !== input.signed && _io1(input.signed)) && (Array.isArray(input.tags) && input.tags.every(elem => "string" === typeof elem)) && ("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)) && ((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)); 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: "KeetaStorageAnchorUpdateMetadataRequest",
            value: input
        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
            method: "createAssert",
            path: _path + "",
            expected: "KeetaStorageAnchorUpdateMetadataRequest",
            value: input
        }, _errorFactory))(input, "$input", true);
    }
    return input;
}; })();
//# sourceMappingURL=common.generated.js.map