@atproto/api 0.19.19 → 0.20.0

package/dist/client/types/chat/bsky/convo/defs.js

@@ -1,484 +1,376 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isConvoRef = isConvoRef;
-exports.validateConvoRef = validateConvoRef;
-exports.isMessageRef = isMessageRef;
-exports.validateMessageRef = validateMessageRef;
-exports.isMessageInput = isMessageInput;
-exports.validateMessageInput = validateMessageInput;
-exports.isMessageView = isMessageView;
-exports.validateMessageView = validateMessageView;
-exports.isSystemMessageReferredUser = isSystemMessageReferredUser;
-exports.validateSystemMessageReferredUser = validateSystemMessageReferredUser;
-exports.isSystemMessageView = isSystemMessageView;
-exports.validateSystemMessageView = validateSystemMessageView;
-exports.isSystemMessageDataAddMember = isSystemMessageDataAddMember;
-exports.validateSystemMessageDataAddMember = validateSystemMessageDataAddMember;
-exports.isSystemMessageDataRemoveMember = isSystemMessageDataRemoveMember;
-exports.validateSystemMessageDataRemoveMember = validateSystemMessageDataRemoveMember;
-exports.isSystemMessageDataMemberJoin = isSystemMessageDataMemberJoin;
-exports.validateSystemMessageDataMemberJoin = validateSystemMessageDataMemberJoin;
-exports.isSystemMessageDataMemberLeave = isSystemMessageDataMemberLeave;
-exports.validateSystemMessageDataMemberLeave = validateSystemMessageDataMemberLeave;
-exports.isSystemMessageDataLockConvo = isSystemMessageDataLockConvo;
-exports.validateSystemMessageDataLockConvo = validateSystemMessageDataLockConvo;
-exports.isSystemMessageDataUnlockConvo = isSystemMessageDataUnlockConvo;
-exports.validateSystemMessageDataUnlockConvo = validateSystemMessageDataUnlockConvo;
-exports.isSystemMessageDataLockConvoPermanently = isSystemMessageDataLockConvoPermanently;
-exports.validateSystemMessageDataLockConvoPermanently = validateSystemMessageDataLockConvoPermanently;
-exports.isSystemMessageDataEditGroup = isSystemMessageDataEditGroup;
-exports.validateSystemMessageDataEditGroup = validateSystemMessageDataEditGroup;
-exports.isSystemMessageDataCreateJoinLink = isSystemMessageDataCreateJoinLink;
-exports.validateSystemMessageDataCreateJoinLink = validateSystemMessageDataCreateJoinLink;
-exports.isSystemMessageDataEditJoinLink = isSystemMessageDataEditJoinLink;
-exports.validateSystemMessageDataEditJoinLink = validateSystemMessageDataEditJoinLink;
-exports.isSystemMessageDataEnableJoinLink = isSystemMessageDataEnableJoinLink;
-exports.validateSystemMessageDataEnableJoinLink = validateSystemMessageDataEnableJoinLink;
-exports.isSystemMessageDataDisableJoinLink = isSystemMessageDataDisableJoinLink;
-exports.validateSystemMessageDataDisableJoinLink = validateSystemMessageDataDisableJoinLink;
-exports.isDeletedMessageView = isDeletedMessageView;
-exports.validateDeletedMessageView = validateDeletedMessageView;
-exports.isMessageViewSender = isMessageViewSender;
-exports.validateMessageViewSender = validateMessageViewSender;
-exports.isReactionView = isReactionView;
-exports.validateReactionView = validateReactionView;
-exports.isReactionViewSender = isReactionViewSender;
-exports.validateReactionViewSender = validateReactionViewSender;
-exports.isMessageAndReactionView = isMessageAndReactionView;
-exports.validateMessageAndReactionView = validateMessageAndReactionView;
-exports.isConvoView = isConvoView;
-exports.validateConvoView = validateConvoView;
-exports.isDirectConvo = isDirectConvo;
-exports.validateDirectConvo = validateDirectConvo;
-exports.isGroupConvo = isGroupConvo;
-exports.validateGroupConvo = validateGroupConvo;
-exports.isLogBeginConvo = isLogBeginConvo;
-exports.validateLogBeginConvo = validateLogBeginConvo;
-exports.isLogAcceptConvo = isLogAcceptConvo;
-exports.validateLogAcceptConvo = validateLogAcceptConvo;
-exports.isLogLeaveConvo = isLogLeaveConvo;
-exports.validateLogLeaveConvo = validateLogLeaveConvo;
-exports.isLogMuteConvo = isLogMuteConvo;
-exports.validateLogMuteConvo = validateLogMuteConvo;
-exports.isLogUnmuteConvo = isLogUnmuteConvo;
-exports.validateLogUnmuteConvo = validateLogUnmuteConvo;
-exports.isLogCreateMessage = isLogCreateMessage;
-exports.validateLogCreateMessage = validateLogCreateMessage;
-exports.isLogDeleteMessage = isLogDeleteMessage;
-exports.validateLogDeleteMessage = validateLogDeleteMessage;
-exports.isLogReadMessage = isLogReadMessage;
-exports.validateLogReadMessage = validateLogReadMessage;
-exports.isLogAddReaction = isLogAddReaction;
-exports.validateLogAddReaction = validateLogAddReaction;
-exports.isLogRemoveReaction = isLogRemoveReaction;
-exports.validateLogRemoveReaction = validateLogRemoveReaction;
-exports.isLogReadConvo = isLogReadConvo;
-exports.validateLogReadConvo = validateLogReadConvo;
-exports.isLogAddMember = isLogAddMember;
-exports.validateLogAddMember = validateLogAddMember;
-exports.isLogRemoveMember = isLogRemoveMember;
-exports.validateLogRemoveMember = validateLogRemoveMember;
-exports.isLogMemberJoin = isLogMemberJoin;
-exports.validateLogMemberJoin = validateLogMemberJoin;
-exports.isLogMemberLeave = isLogMemberLeave;
-exports.validateLogMemberLeave = validateLogMemberLeave;
-exports.isLogLockConvo = isLogLockConvo;
-exports.validateLogLockConvo = validateLogLockConvo;
-exports.isLogUnlockConvo = isLogUnlockConvo;
-exports.validateLogUnlockConvo = validateLogUnlockConvo;
-exports.isLogLockConvoPermanently = isLogLockConvoPermanently;
-exports.validateLogLockConvoPermanently = validateLogLockConvoPermanently;
-exports.isLogEditGroup = isLogEditGroup;
-exports.validateLogEditGroup = validateLogEditGroup;
-exports.isLogCreateJoinLink = isLogCreateJoinLink;
-exports.validateLogCreateJoinLink = validateLogCreateJoinLink;
-exports.isLogEditJoinLink = isLogEditJoinLink;
-exports.validateLogEditJoinLink = validateLogEditJoinLink;
-exports.isLogEnableJoinLink = isLogEnableJoinLink;
-exports.validateLogEnableJoinLink = validateLogEnableJoinLink;
-exports.isLogDisableJoinLink = isLogDisableJoinLink;
-exports.validateLogDisableJoinLink = validateLogDisableJoinLink;
-exports.isLogIncomingJoinRequest = isLogIncomingJoinRequest;
-exports.validateLogIncomingJoinRequest = validateLogIncomingJoinRequest;
-exports.isLogApproveJoinRequest = isLogApproveJoinRequest;
-exports.validateLogApproveJoinRequest = validateLogApproveJoinRequest;
-exports.isLogRejectJoinRequest = isLogRejectJoinRequest;
-exports.validateLogRejectJoinRequest = validateLogRejectJoinRequest;
-exports.isLogOutgoingJoinRequest = isLogOutgoingJoinRequest;
-exports.validateLogOutgoingJoinRequest = validateLogOutgoingJoinRequest;
-const lexicons_1 = require("../../../../lexicons");
-const util_1 = require("../../../../util");
-const is$typed = util_1.is$typed, validate = lexicons_1.validate;
+import { validate as _validate } from '../../../../lexicons.js';
+import { is$typed as _is$typed, } from '../../../../util.js';
+const is$typed = _is$typed, validate = _validate;
 const id = 'chat.bsky.convo.defs';
 const hashConvoRef = 'convoRef';
-function isConvoRef(v) {
+export function isConvoRef(v) {
     return is$typed(v, id, hashConvoRef);
 }
-function validateConvoRef(v) {
+export function validateConvoRef(v) {
     return validate(v, id, hashConvoRef);
 }
 const hashMessageRef = 'messageRef';
-function isMessageRef(v) {
+export function isMessageRef(v) {
     return is$typed(v, id, hashMessageRef);
 }
-function validateMessageRef(v) {
+export function validateMessageRef(v) {
     return validate(v, id, hashMessageRef);
 }
 const hashMessageInput = 'messageInput';
-function isMessageInput(v) {
+export function isMessageInput(v) {
     return is$typed(v, id, hashMessageInput);
 }
-function validateMessageInput(v) {
+export function validateMessageInput(v) {
     return validate(v, id, hashMessageInput);
 }
 const hashMessageView = 'messageView';
-function isMessageView(v) {
+export function isMessageView(v) {
     return is$typed(v, id, hashMessageView);
 }
-function validateMessageView(v) {
+export function validateMessageView(v) {
     return validate(v, id, hashMessageView);
 }
 const hashSystemMessageReferredUser = 'systemMessageReferredUser';
-function isSystemMessageReferredUser(v) {
+export function isSystemMessageReferredUser(v) {
     return is$typed(v, id, hashSystemMessageReferredUser);
 }
-function validateSystemMessageReferredUser(v) {
+export function validateSystemMessageReferredUser(v) {
     return validate(v, id, hashSystemMessageReferredUser);
 }
 const hashSystemMessageView = 'systemMessageView';
-function isSystemMessageView(v) {
+export function isSystemMessageView(v) {
     return is$typed(v, id, hashSystemMessageView);
 }
-function validateSystemMessageView(v) {
+export function validateSystemMessageView(v) {
     return validate(v, id, hashSystemMessageView);
 }
 const hashSystemMessageDataAddMember = 'systemMessageDataAddMember';
-function isSystemMessageDataAddMember(v) {
+export function isSystemMessageDataAddMember(v) {
     return is$typed(v, id, hashSystemMessageDataAddMember);
 }
-function validateSystemMessageDataAddMember(v) {
+export function validateSystemMessageDataAddMember(v) {
     return validate(v, id, hashSystemMessageDataAddMember);
 }
 const hashSystemMessageDataRemoveMember = 'systemMessageDataRemoveMember';
-function isSystemMessageDataRemoveMember(v) {
+export function isSystemMessageDataRemoveMember(v) {
     return is$typed(v, id, hashSystemMessageDataRemoveMember);
 }
-function validateSystemMessageDataRemoveMember(v) {
+export function validateSystemMessageDataRemoveMember(v) {
     return validate(v, id, hashSystemMessageDataRemoveMember);
 }
 const hashSystemMessageDataMemberJoin = 'systemMessageDataMemberJoin';
-function isSystemMessageDataMemberJoin(v) {
+export function isSystemMessageDataMemberJoin(v) {
     return is$typed(v, id, hashSystemMessageDataMemberJoin);
 }
-function validateSystemMessageDataMemberJoin(v) {
+export function validateSystemMessageDataMemberJoin(v) {
     return validate(v, id, hashSystemMessageDataMemberJoin);
 }
 const hashSystemMessageDataMemberLeave = 'systemMessageDataMemberLeave';
-function isSystemMessageDataMemberLeave(v) {
+export function isSystemMessageDataMemberLeave(v) {
     return is$typed(v, id, hashSystemMessageDataMemberLeave);
 }
-function validateSystemMessageDataMemberLeave(v) {
+export function validateSystemMessageDataMemberLeave(v) {
     return validate(v, id, hashSystemMessageDataMemberLeave);
 }
 const hashSystemMessageDataLockConvo = 'systemMessageDataLockConvo';
-function isSystemMessageDataLockConvo(v) {
+export function isSystemMessageDataLockConvo(v) {
     return is$typed(v, id, hashSystemMessageDataLockConvo);
 }
-function validateSystemMessageDataLockConvo(v) {
+export function validateSystemMessageDataLockConvo(v) {
     return validate(v, id, hashSystemMessageDataLockConvo);
 }
 const hashSystemMessageDataUnlockConvo = 'systemMessageDataUnlockConvo';
-function isSystemMessageDataUnlockConvo(v) {
+export function isSystemMessageDataUnlockConvo(v) {
     return is$typed(v, id, hashSystemMessageDataUnlockConvo);
 }
-function validateSystemMessageDataUnlockConvo(v) {
+export function validateSystemMessageDataUnlockConvo(v) {
     return validate(v, id, hashSystemMessageDataUnlockConvo);
 }
 const hashSystemMessageDataLockConvoPermanently = 'systemMessageDataLockConvoPermanently';
-function isSystemMessageDataLockConvoPermanently(v) {
+export function isSystemMessageDataLockConvoPermanently(v) {
     return is$typed(v, id, hashSystemMessageDataLockConvoPermanently);
 }
-function validateSystemMessageDataLockConvoPermanently(v) {
+export function validateSystemMessageDataLockConvoPermanently(v) {
     return validate(v, id, hashSystemMessageDataLockConvoPermanently);
 }
 const hashSystemMessageDataEditGroup = 'systemMessageDataEditGroup';
-function isSystemMessageDataEditGroup(v) {
+export function isSystemMessageDataEditGroup(v) {
     return is$typed(v, id, hashSystemMessageDataEditGroup);
 }
-function validateSystemMessageDataEditGroup(v) {
+export function validateSystemMessageDataEditGroup(v) {
     return validate(v, id, hashSystemMessageDataEditGroup);
 }
 const hashSystemMessageDataCreateJoinLink = 'systemMessageDataCreateJoinLink';
-function isSystemMessageDataCreateJoinLink(v) {
+export function isSystemMessageDataCreateJoinLink(v) {
     return is$typed(v, id, hashSystemMessageDataCreateJoinLink);
 }
-function validateSystemMessageDataCreateJoinLink(v) {
+export function validateSystemMessageDataCreateJoinLink(v) {
     return validate(v, id, hashSystemMessageDataCreateJoinLink);
 }
 const hashSystemMessageDataEditJoinLink = 'systemMessageDataEditJoinLink';
-function isSystemMessageDataEditJoinLink(v) {
+export function isSystemMessageDataEditJoinLink(v) {
     return is$typed(v, id, hashSystemMessageDataEditJoinLink);
 }
-function validateSystemMessageDataEditJoinLink(v) {
+export function validateSystemMessageDataEditJoinLink(v) {
     return validate(v, id, hashSystemMessageDataEditJoinLink);
 }
 const hashSystemMessageDataEnableJoinLink = 'systemMessageDataEnableJoinLink';
-function isSystemMessageDataEnableJoinLink(v) {
+export function isSystemMessageDataEnableJoinLink(v) {
     return is$typed(v, id, hashSystemMessageDataEnableJoinLink);
 }
-function validateSystemMessageDataEnableJoinLink(v) {
+export function validateSystemMessageDataEnableJoinLink(v) {
     return validate(v, id, hashSystemMessageDataEnableJoinLink);
 }
 const hashSystemMessageDataDisableJoinLink = 'systemMessageDataDisableJoinLink';
-function isSystemMessageDataDisableJoinLink(v) {
+export function isSystemMessageDataDisableJoinLink(v) {
     return is$typed(v, id, hashSystemMessageDataDisableJoinLink);
 }
-function validateSystemMessageDataDisableJoinLink(v) {
+export function validateSystemMessageDataDisableJoinLink(v) {
     return validate(v, id, hashSystemMessageDataDisableJoinLink);
 }
 const hashDeletedMessageView = 'deletedMessageView';
-function isDeletedMessageView(v) {
+export function isDeletedMessageView(v) {
     return is$typed(v, id, hashDeletedMessageView);
 }
-function validateDeletedMessageView(v) {
+export function validateDeletedMessageView(v) {
     return validate(v, id, hashDeletedMessageView);
 }
 const hashMessageViewSender = 'messageViewSender';
-function isMessageViewSender(v) {
+export function isMessageViewSender(v) {
     return is$typed(v, id, hashMessageViewSender);
 }
-function validateMessageViewSender(v) {
+export function validateMessageViewSender(v) {
     return validate(v, id, hashMessageViewSender);
 }
 const hashReactionView = 'reactionView';
-function isReactionView(v) {
+export function isReactionView(v) {
     return is$typed(v, id, hashReactionView);
 }
-function validateReactionView(v) {
+export function validateReactionView(v) {
     return validate(v, id, hashReactionView);
 }
 const hashReactionViewSender = 'reactionViewSender';
-function isReactionViewSender(v) {
+export function isReactionViewSender(v) {
     return is$typed(v, id, hashReactionViewSender);
 }
-function validateReactionViewSender(v) {
+export function validateReactionViewSender(v) {
     return validate(v, id, hashReactionViewSender);
 }
 const hashMessageAndReactionView = 'messageAndReactionView';
-function isMessageAndReactionView(v) {
+export function isMessageAndReactionView(v) {
     return is$typed(v, id, hashMessageAndReactionView);
 }
-function validateMessageAndReactionView(v) {
+export function validateMessageAndReactionView(v) {
     return validate(v, id, hashMessageAndReactionView);
 }
 const hashConvoView = 'convoView';
-function isConvoView(v) {
+export function isConvoView(v) {
     return is$typed(v, id, hashConvoView);
 }
-function validateConvoView(v) {
+export function validateConvoView(v) {
     return validate(v, id, hashConvoView);
 }
 const hashDirectConvo = 'directConvo';
-function isDirectConvo(v) {
+export function isDirectConvo(v) {
     return is$typed(v, id, hashDirectConvo);
 }
-function validateDirectConvo(v) {
+export function validateDirectConvo(v) {
     return validate(v, id, hashDirectConvo);
 }
 const hashGroupConvo = 'groupConvo';
-function isGroupConvo(v) {
+export function isGroupConvo(v) {
     return is$typed(v, id, hashGroupConvo);
 }
-function validateGroupConvo(v) {
+export function validateGroupConvo(v) {
     return validate(v, id, hashGroupConvo);
 }
 const hashLogBeginConvo = 'logBeginConvo';
-function isLogBeginConvo(v) {
+export function isLogBeginConvo(v) {
     return is$typed(v, id, hashLogBeginConvo);
 }
-function validateLogBeginConvo(v) {
+export function validateLogBeginConvo(v) {
     return validate(v, id, hashLogBeginConvo);
 }
 const hashLogAcceptConvo = 'logAcceptConvo';
-function isLogAcceptConvo(v) {
+export function isLogAcceptConvo(v) {
     return is$typed(v, id, hashLogAcceptConvo);
 }
-function validateLogAcceptConvo(v) {
+export function validateLogAcceptConvo(v) {
     return validate(v, id, hashLogAcceptConvo);
 }
 const hashLogLeaveConvo = 'logLeaveConvo';
-function isLogLeaveConvo(v) {
+export function isLogLeaveConvo(v) {
     return is$typed(v, id, hashLogLeaveConvo);
 }
-function validateLogLeaveConvo(v) {
+export function validateLogLeaveConvo(v) {
     return validate(v, id, hashLogLeaveConvo);
 }
 const hashLogMuteConvo = 'logMuteConvo';
-function isLogMuteConvo(v) {
+export function isLogMuteConvo(v) {
     return is$typed(v, id, hashLogMuteConvo);
 }
-function validateLogMuteConvo(v) {
+export function validateLogMuteConvo(v) {
     return validate(v, id, hashLogMuteConvo);
 }
 const hashLogUnmuteConvo = 'logUnmuteConvo';
-function isLogUnmuteConvo(v) {
+export function isLogUnmuteConvo(v) {
     return is$typed(v, id, hashLogUnmuteConvo);
 }
-function validateLogUnmuteConvo(v) {
+export function validateLogUnmuteConvo(v) {
     return validate(v, id, hashLogUnmuteConvo);
 }
 const hashLogCreateMessage = 'logCreateMessage';
-function isLogCreateMessage(v) {
+export function isLogCreateMessage(v) {
     return is$typed(v, id, hashLogCreateMessage);
 }
-function validateLogCreateMessage(v) {
+export function validateLogCreateMessage(v) {
     return validate(v, id, hashLogCreateMessage);
 }
 const hashLogDeleteMessage = 'logDeleteMessage';
-function isLogDeleteMessage(v) {
+export function isLogDeleteMessage(v) {
     return is$typed(v, id, hashLogDeleteMessage);
 }
-function validateLogDeleteMessage(v) {
+export function validateLogDeleteMessage(v) {
     return validate(v, id, hashLogDeleteMessage);
 }
 const hashLogReadMessage = 'logReadMessage';
-function isLogReadMessage(v) {
+export function isLogReadMessage(v) {
     return is$typed(v, id, hashLogReadMessage);
 }
-function validateLogReadMessage(v) {
+export function validateLogReadMessage(v) {
     return validate(v, id, hashLogReadMessage);
 }
 const hashLogAddReaction = 'logAddReaction';
-function isLogAddReaction(v) {
+export function isLogAddReaction(v) {
     return is$typed(v, id, hashLogAddReaction);
 }
-function validateLogAddReaction(v) {
+export function validateLogAddReaction(v) {
     return validate(v, id, hashLogAddReaction);
 }
 const hashLogRemoveReaction = 'logRemoveReaction';
-function isLogRemoveReaction(v) {
+export function isLogRemoveReaction(v) {
     return is$typed(v, id, hashLogRemoveReaction);
 }
-function validateLogRemoveReaction(v) {
+export function validateLogRemoveReaction(v) {
     return validate(v, id, hashLogRemoveReaction);
 }
 const hashLogReadConvo = 'logReadConvo';
-function isLogReadConvo(v) {
+export function isLogReadConvo(v) {
     return is$typed(v, id, hashLogReadConvo);
 }
-function validateLogReadConvo(v) {
+export function validateLogReadConvo(v) {
     return validate(v, id, hashLogReadConvo);
 }
 const hashLogAddMember = 'logAddMember';
-function isLogAddMember(v) {
+export function isLogAddMember(v) {
     return is$typed(v, id, hashLogAddMember);
 }
-function validateLogAddMember(v) {
+export function validateLogAddMember(v) {
     return validate(v, id, hashLogAddMember);
 }
 const hashLogRemoveMember = 'logRemoveMember';
-function isLogRemoveMember(v) {
+export function isLogRemoveMember(v) {
     return is$typed(v, id, hashLogRemoveMember);
 }
-function validateLogRemoveMember(v) {
+export function validateLogRemoveMember(v) {
     return validate(v, id, hashLogRemoveMember);
 }
 const hashLogMemberJoin = 'logMemberJoin';
-function isLogMemberJoin(v) {
+export function isLogMemberJoin(v) {
     return is$typed(v, id, hashLogMemberJoin);
 }
-function validateLogMemberJoin(v) {
+export function validateLogMemberJoin(v) {
     return validate(v, id, hashLogMemberJoin);
 }
 const hashLogMemberLeave = 'logMemberLeave';
-function isLogMemberLeave(v) {
+export function isLogMemberLeave(v) {
     return is$typed(v, id, hashLogMemberLeave);
 }
-function validateLogMemberLeave(v) {
+export function validateLogMemberLeave(v) {
     return validate(v, id, hashLogMemberLeave);
 }
 const hashLogLockConvo = 'logLockConvo';
-function isLogLockConvo(v) {
+export function isLogLockConvo(v) {
     return is$typed(v, id, hashLogLockConvo);
 }
-function validateLogLockConvo(v) {
+export function validateLogLockConvo(v) {
     return validate(v, id, hashLogLockConvo);
 }
 const hashLogUnlockConvo = 'logUnlockConvo';
-function isLogUnlockConvo(v) {
+export function isLogUnlockConvo(v) {
     return is$typed(v, id, hashLogUnlockConvo);
 }
-function validateLogUnlockConvo(v) {
+export function validateLogUnlockConvo(v) {
     return validate(v, id, hashLogUnlockConvo);
 }
 const hashLogLockConvoPermanently = 'logLockConvoPermanently';
-function isLogLockConvoPermanently(v) {
+export function isLogLockConvoPermanently(v) {
     return is$typed(v, id, hashLogLockConvoPermanently);
 }
-function validateLogLockConvoPermanently(v) {
+export function validateLogLockConvoPermanently(v) {
     return validate(v, id, hashLogLockConvoPermanently);
 }
 const hashLogEditGroup = 'logEditGroup';
-function isLogEditGroup(v) {
+export function isLogEditGroup(v) {
     return is$typed(v, id, hashLogEditGroup);
 }
-function validateLogEditGroup(v) {
+export function validateLogEditGroup(v) {
     return validate(v, id, hashLogEditGroup);
 }
 const hashLogCreateJoinLink = 'logCreateJoinLink';
-function isLogCreateJoinLink(v) {
+export function isLogCreateJoinLink(v) {
     return is$typed(v, id, hashLogCreateJoinLink);
 }
-function validateLogCreateJoinLink(v) {
+export function validateLogCreateJoinLink(v) {
     return validate(v, id, hashLogCreateJoinLink);
 }
 const hashLogEditJoinLink = 'logEditJoinLink';
-function isLogEditJoinLink(v) {
+export function isLogEditJoinLink(v) {
     return is$typed(v, id, hashLogEditJoinLink);
 }
-function validateLogEditJoinLink(v) {
+export function validateLogEditJoinLink(v) {
     return validate(v, id, hashLogEditJoinLink);
 }
 const hashLogEnableJoinLink = 'logEnableJoinLink';
-function isLogEnableJoinLink(v) {
+export function isLogEnableJoinLink(v) {
     return is$typed(v, id, hashLogEnableJoinLink);
 }
-function validateLogEnableJoinLink(v) {
+export function validateLogEnableJoinLink(v) {
     return validate(v, id, hashLogEnableJoinLink);
 }
 const hashLogDisableJoinLink = 'logDisableJoinLink';
-function isLogDisableJoinLink(v) {
+export function isLogDisableJoinLink(v) {
     return is$typed(v, id, hashLogDisableJoinLink);
 }
-function validateLogDisableJoinLink(v) {
+export function validateLogDisableJoinLink(v) {
     return validate(v, id, hashLogDisableJoinLink);
 }
 const hashLogIncomingJoinRequest = 'logIncomingJoinRequest';
-function isLogIncomingJoinRequest(v) {
+export function isLogIncomingJoinRequest(v) {
     return is$typed(v, id, hashLogIncomingJoinRequest);
 }
-function validateLogIncomingJoinRequest(v) {
+export function validateLogIncomingJoinRequest(v) {
     return validate(v, id, hashLogIncomingJoinRequest);
 }
 const hashLogApproveJoinRequest = 'logApproveJoinRequest';
-function isLogApproveJoinRequest(v) {
+export function isLogApproveJoinRequest(v) {
     return is$typed(v, id, hashLogApproveJoinRequest);
 }
-function validateLogApproveJoinRequest(v) {
+export function validateLogApproveJoinRequest(v) {
     return validate(v, id, hashLogApproveJoinRequest);
 }
 const hashLogRejectJoinRequest = 'logRejectJoinRequest';
-function isLogRejectJoinRequest(v) {
+export function isLogRejectJoinRequest(v) {
     return is$typed(v, id, hashLogRejectJoinRequest);
 }
-function validateLogRejectJoinRequest(v) {
+export function validateLogRejectJoinRequest(v) {
     return validate(v, id, hashLogRejectJoinRequest);
 }
 const hashLogOutgoingJoinRequest = 'logOutgoingJoinRequest';
-function isLogOutgoingJoinRequest(v) {
+export function isLogOutgoingJoinRequest(v) {
     return is$typed(v, id, hashLogOutgoingJoinRequest);
 }
-function validateLogOutgoingJoinRequest(v) {
+export function validateLogOutgoingJoinRequest(v) {
     return validate(v, id, hashLogOutgoingJoinRequest);
 }
 //# sourceMappingURL=defs.js.map