@seed-hypermedia/client 0.0.1

package/dist/chunk-YUKHBJYL.mjs

@@ -0,0 +1,1044 @@
+// src/hm-types.ts
+import * as z from "zod";
+var BlockRangeSchema = z.object({
+  // a block range should either have start+end
+  start: z.number().optional(),
+  end: z.number().optional(),
+  // or have expanded bool
+  expanded: z.boolean().optional()
+});
+var unpackedHmIdSchema = z.object({
+  id: z.string(),
+  uid: z.string(),
+  path: z.array(z.string()).nullable(),
+  version: z.string().nullable(),
+  blockRef: z.string().nullable(),
+  blockRange: BlockRangeSchema.nullable(),
+  hostname: z.string().nullable(),
+  scheme: z.string().nullable(),
+  latest: z.boolean().nullable().optional(),
+  // deprecated:
+  targetDocUid: z.string().nullable().optional(),
+  targetDocPath: z.array(z.string()).nullable().optional()
+});
+var HMBlockChildrenTypeSchema = z.union([z.literal("Group"), z.literal("Ordered"), z.literal("Unordered"), z.literal("Blockquote")]).nullable();
+var HMEmbedViewSchema = z.union([z.literal("Content"), z.literal("Card"), z.literal("Comments")]);
+var HMQueryStyleSchema = z.union([z.literal("Card"), z.literal("List")]);
+var baseAnnotationProperties = {
+  starts: z.array(z.number()),
+  ends: z.array(z.number()),
+  attributes: z.object({}).optional(),
+  link: z.literal("").optional()
+};
+var BoldAnnotationSchema = z.object({
+  type: z.literal("Bold"),
+  ...baseAnnotationProperties
+}).strict();
+var ItalicAnnotationSchema = z.object({
+  type: z.literal("Italic"),
+  ...baseAnnotationProperties
+}).strict();
+var UnderlineAnnotationSchema = z.object({
+  type: z.literal("Underline"),
+  ...baseAnnotationProperties
+}).strict();
+var StrikeAnnotationSchema = z.object({
+  type: z.literal("Strike"),
+  ...baseAnnotationProperties
+}).strict();
+var CodeAnnotationSchema = z.object({
+  type: z.literal("Code"),
+  ...baseAnnotationProperties
+}).strict();
+var LinkAnnotationSchema = z.object({
+  type: z.literal("Link"),
+  ...baseAnnotationProperties,
+  link: z.string().optional()
+  // this should be required but we have seen some data that is missing it
+}).strict();
+var InlineEmbedAnnotationSchema = z.object({
+  type: z.literal("Embed"),
+  ...baseAnnotationProperties,
+  link: z.string()
+}).strict();
+var HighlightAnnotationSchema = z.object({
+  type: z.literal("Range"),
+  ...baseAnnotationProperties
+}).strict();
+var HMAnnotationSchema = z.discriminatedUnion("type", [
+  BoldAnnotationSchema,
+  ItalicAnnotationSchema,
+  UnderlineAnnotationSchema,
+  StrikeAnnotationSchema,
+  CodeAnnotationSchema,
+  LinkAnnotationSchema,
+  InlineEmbedAnnotationSchema,
+  HighlightAnnotationSchema
+]);
+var HMAnnotationsSchema = z.array(HMAnnotationSchema).optional();
+var blockBaseProperties = {
+  id: z.string(),
+  revision: z.string().optional(),
+  attributes: z.object({}).optional().default({}),
+  // EMPTY ATTRIBUTES, override in specific block schemas
+  annotations: z.array(z.never()).optional(),
+  // EMPTY ANNOTATIONS, override in specific block schemas
+  text: z.literal("").optional(),
+  // EMPTY TEXT, override in specific block schemas
+  link: z.literal("").optional()
+  // EMPTY LINK, override in specific block schemas
+};
+var textBlockProperties = {
+  text: z.string().default(""),
+  annotations: HMAnnotationsSchema
+};
+var parentBlockAttributes = {
+  childrenType: HMBlockChildrenTypeSchema.optional()
+};
+var HMBlockParagraphSchema = z.object({
+  type: z.literal("Paragraph"),
+  ...blockBaseProperties,
+  ...textBlockProperties,
+  attributes: z.object(parentBlockAttributes).optional().default({})
+}).strict();
+var HMBlockHeadingSchema = z.object({
+  type: z.literal("Heading"),
+  ...blockBaseProperties,
+  ...textBlockProperties,
+  attributes: z.object(parentBlockAttributes).optional().default({})
+}).strict();
+var HMBlockCodeSchema = z.object({
+  type: z.literal("Code"),
+  ...blockBaseProperties,
+  attributes: z.object({
+    ...parentBlockAttributes,
+    language: z.string().optional()
+  }).optional().default({}),
+  text: z.string().default("")
+}).strict();
+var HMBlockMathSchema = z.object({
+  type: z.literal("Math"),
+  ...blockBaseProperties,
+  attributes: z.object(parentBlockAttributes).optional().default({}),
+  text: z.string().default("")
+}).strict();
+function toNumber(value) {
+  if (typeof value == "number" && !isNaN(value)) {
+    return value;
+  }
+  if (typeof value == "string") {
+    const converted = Number(value);
+    if (!isNaN(converted)) {
+      return converted;
+    }
+  }
+  console.warn("Value must be a number or a string that can be converted to a number", value);
+  return null;
+}
+var HMBlockImageSchema = z.object({
+  type: z.literal("Image"),
+  ...blockBaseProperties,
+  ...textBlockProperties,
+  attributes: z.object({
+    ...parentBlockAttributes,
+    width: z.number().optional(),
+    name: z.string().optional()
+  }).optional().default({}),
+  link: z.string()
+}).strict();
+var HMBlockVideoSchema = z.object({
+  type: z.literal("Video"),
+  ...blockBaseProperties,
+  attributes: z.object({
+    ...parentBlockAttributes,
+    width: z.number().optional(),
+    name: z.string().optional()
+  }).optional().default({}),
+  link: z.string()
+}).strict();
+var HMBlockFileSchema = z.object({
+  type: z.literal("File"),
+  ...blockBaseProperties,
+  attributes: z.object({
+    ...parentBlockAttributes,
+    size: z.number().optional().transform(toNumber),
+    // number of bytes, as a string
+    name: z.string().optional()
+  }).optional().default({}),
+  link: z.string()
+}).strict();
+var HMBlockButtonAlignmentSchema = z.union([z.literal("flex-start"), z.literal("center"), z.literal("flex-end")]).optional();
+var HMBlockButtonSchema = z.object({
+  type: z.literal("Button"),
+  ...blockBaseProperties,
+  attributes: z.object({
+    ...parentBlockAttributes,
+    name: z.string().optional(),
+    alignment: HMBlockButtonAlignmentSchema
+  }).optional().default({}),
+  text: z.string().optional(),
+  link: z.string()
+}).strict();
+var HMBlockEmbedSchema = z.object({
+  type: z.literal("Embed"),
+  ...blockBaseProperties,
+  link: z.string(),
+  // should be a hm:// URL
+  attributes: z.object({
+    ...parentBlockAttributes,
+    view: HMEmbedViewSchema.optional()
+  }).optional().default({})
+}).strict();
+var HMBlockWebEmbedSchema = z.object({
+  type: z.literal("WebEmbed"),
+  ...blockBaseProperties,
+  link: z.string()
+  // should be a HTTP(S) URL
+}).strict();
+var HMBlockNostrSchema = z.object({
+  type: z.literal("Nostr"),
+  ...blockBaseProperties,
+  link: z.string()
+  // should be a nostr:// URL
+}).strict();
+var HMTimestampSchema = z.object({
+  seconds: z.bigint().or(z.number()),
+  nanos: z.number()
+}).strict().or(z.string());
+var HMBlockNodeSchema = z.lazy(
+  () => z.object({
+    children: z.array(HMBlockNodeSchema).optional(),
+    block: HMBlockSchema
+  })
+);
+var HMDocumentMetadataSchema = z.object({
+  name: z.string().optional(),
+  summary: z.string().optional(),
+  icon: z.string().optional(),
+  thumbnail: z.string().optional(),
+  // DEPRECATED
+  cover: z.string().optional(),
+  siteUrl: z.string().optional(),
+  layout: z.union([z.literal("Seed/Experimental/Newspaper"), z.literal("")]).optional(),
+  displayPublishTime: z.string().optional(),
+  seedExperimentalLogo: z.string().optional(),
+  seedExperimentalHomeOrder: z.union([z.literal("UpdatedFirst"), z.literal("CreatedFirst")]).optional(),
+  showOutline: z.boolean().optional(),
+  showActivity: z.boolean().optional(),
+  contentWidth: z.union([z.literal("S"), z.literal("M"), z.literal("L")]).optional(),
+  theme: z.object({
+    headerLayout: z.union([z.literal("Center"), z.literal("")]).optional()
+  }).optional(),
+  // Import taxonomy fields (comma-separated values from external sources like WordPress)
+  importCategories: z.string().optional(),
+  importTags: z.string().optional()
+});
+function hmMetadataJsonCorrection(metadata) {
+  if (typeof metadata.theme === "string") {
+    return {
+      ...metadata,
+      theme: {}
+    };
+  }
+  return metadata;
+}
+var visibilityMap = {
+  0: "PUBLIC",
+  1: "PUBLIC",
+  2: "PRIVATE",
+  RESOURCE_VISIBILITY_UNSPECIFIED: "PUBLIC",
+  RESOURCE_VISIBILITY_PUBLIC: "PUBLIC",
+  RESOURCE_VISIBILITY_PRIVATE: "PRIVATE",
+  UNSPECIFIED: "PUBLIC",
+  PUBLIC: "PUBLIC",
+  PRIVATE: "PRIVATE"
+};
+var HMResourceVisibilitySchema = z.union([z.string(), z.number()]).transform((val) => visibilityMap[val] ?? "PUBLIC");
+var HMCommentSchema = z.object({
+  id: z.string(),
+  version: z.string(),
+  author: z.string(),
+  targetAccount: z.string(),
+  targetPath: z.string().optional(),
+  targetVersion: z.string(),
+  replyParent: z.string().optional(),
+  threadRoot: z.string().optional(),
+  threadRootVersion: z.string().optional(),
+  capability: z.string().optional(),
+  content: z.array(HMBlockNodeSchema),
+  createTime: HMTimestampSchema,
+  updateTime: HMTimestampSchema,
+  visibility: HMResourceVisibilitySchema
+});
+var HMBreadcrumbSchema = z.object({
+  name: z.string(),
+  path: z.string(),
+  isMissing: z.boolean().optional()
+});
+var HMCommentGroupSchema = z.object({
+  comments: z.array(HMCommentSchema),
+  moreCommentsCount: z.number(),
+  id: z.string(),
+  type: z.literal("commentGroup")
+});
+var HMExternalCommentGroupSchema = z.object({
+  comments: z.array(HMCommentSchema),
+  moreCommentsCount: z.number(),
+  id: z.string(),
+  target: z.lazy(() => HMMetadataPayloadSchema),
+  type: z.literal("externalCommentGroup")
+});
+var HMActivitySummarySchema = z.object({
+  latestCommentTime: HMTimestampSchema.optional(),
+  latestCommentId: z.string(),
+  commentCount: z.number(),
+  latestChangeTime: HMTimestampSchema,
+  isUnread: z.boolean()
+});
+var HMGenerationInfoSchema = z.object({
+  genesis: z.string(),
+  generation: z.union([z.bigint(), z.coerce.bigint()])
+});
+var HMRedirectInfoSchema = z.object({
+  type: z.literal("redirect"),
+  target: z.string()
+});
+var HMDocumentInfoSchema = z.object({
+  type: z.literal("document"),
+  id: unpackedHmIdSchema,
+  path: z.array(z.string()),
+  authors: z.array(z.string()),
+  createTime: HMTimestampSchema,
+  updateTime: HMTimestampSchema,
+  sortTime: z.instanceof(Date),
+  genesis: z.string(),
+  version: z.string(),
+  breadcrumbs: z.array(HMBreadcrumbSchema),
+  activitySummary: HMActivitySummarySchema,
+  generationInfo: HMGenerationInfoSchema,
+  redirectInfo: HMRedirectInfoSchema.optional(),
+  metadata: HMDocumentMetadataSchema,
+  visibility: HMResourceVisibilitySchema
+});
+var HMQueryResultSchema = z.object({
+  in: unpackedHmIdSchema,
+  results: z.array(HMDocumentInfoSchema),
+  mode: z.union([z.literal("Children"), z.literal("AllDescendants")]).optional()
+});
+var HMRoleSchema = z.enum(["writer", "agent", "none", "owner"]);
+var HMMetadataPayloadSchema = z.object({
+  id: unpackedHmIdSchema,
+  metadata: HMDocumentMetadataSchema.or(z.null()),
+  hasSite: z.boolean().optional()
+}).strict();
+var HMAccountPayloadSchema = HMMetadataPayloadSchema.extend({
+  type: z.literal("account")
+});
+var HMAccountNotFoundSchema = z.object({
+  type: z.literal("account-not-found"),
+  uid: z.string()
+});
+var HMAccountResultSchema = z.discriminatedUnion("type", [HMAccountPayloadSchema, HMAccountNotFoundSchema]);
+var HMAccountsMetadataSchema = z.record(
+  z.string(),
+  // account uid
+  HMMetadataPayloadSchema
+);
+var HMQueryInclusionSchema = z.object({
+  space: z.string(),
+  path: z.string().optional(),
+  mode: z.union([z.literal("Children"), z.literal("AllDescendants")])
+});
+var HMQuerySortSchema = z.object({
+  reverse: z.boolean().default(false),
+  term: z.union([
+    z.literal("Path"),
+    z.literal("Title"),
+    z.literal("CreateTime"),
+    z.literal("UpdateTime"),
+    z.literal("DisplayTime")
+  ])
+});
+var HMQuerySchema = z.object({
+  includes: z.array(HMQueryInclusionSchema),
+  sort: z.array(HMQuerySortSchema).optional(),
+  limit: z.preprocess(
+    (val) => val === "" || val === null || val === void 0 ? void 0 : val,
+    z.coerce.number().optional()
+  )
+});
+var HMBlockQuerySchema = z.object({
+  type: z.literal("Query"),
+  ...blockBaseProperties,
+  attributes: z.object({
+    ...parentBlockAttributes,
+    style: HMQueryStyleSchema.optional().default("Card"),
+    columnCount: z.number().optional().default(3),
+    query: HMQuerySchema,
+    banner: z.boolean().optional().default(false)
+  })
+}).strict();
+var HMBlockGroupSchema = z.object({
+  type: z.literal("Group"),
+  id: z.string()
+});
+var HMBlockLinkSchema = z.object({
+  type: z.literal("Link"),
+  id: z.string(),
+  link: z.string().optional(),
+  text: z.string()
+});
+var HMBlockKnownSchema = z.discriminatedUnion("type", [
+  HMBlockParagraphSchema,
+  HMBlockHeadingSchema,
+  HMBlockCodeSchema,
+  HMBlockMathSchema,
+  HMBlockImageSchema,
+  HMBlockVideoSchema,
+  HMBlockFileSchema,
+  HMBlockButtonSchema,
+  HMBlockEmbedSchema,
+  HMBlockWebEmbedSchema,
+  HMBlockNostrSchema,
+  HMBlockQuerySchema,
+  HMBlockGroupSchema,
+  HMBlockLinkSchema
+]);
+var HMBlockUnknownSchema = z.object({
+  type: z.string(),
+  id: z.string(),
+  revision: z.string().optional(),
+  attributes: z.record(z.any()).optional(),
+  annotations: z.array(z.any()).optional(),
+  text: z.string().optional(),
+  link: z.string().optional()
+}).passthrough();
+var HMBlockSchema = z.union([HMBlockKnownSchema, HMBlockUnknownSchema]);
+var knownBlockTypes = new Set(HMBlockKnownSchema.optionsMap.keys());
+function isKnownBlockType(btype) {
+  return knownBlockTypes.has(btype);
+}
+var HMDocumentSchema = z.object({
+  content: z.array(HMBlockNodeSchema).default([]),
+  version: z.string().default(""),
+  account: z.string().default(""),
+  authors: z.array(z.string()),
+  path: z.string().default(""),
+  createTime: z.union([HMTimestampSchema, z.string()]).default(""),
+  updateTime: z.union([HMTimestampSchema, z.string()]).default(""),
+  metadata: HMDocumentMetadataSchema,
+  detachedBlocks: z.record(z.string(), HMBlockNodeSchema).optional(),
+  genesis: z.string(),
+  generationInfo: HMGenerationInfoSchema.optional(),
+  visibility: HMResourceVisibilitySchema
+});
+var HMResourceDocumentSchema = z.object({
+  type: z.literal("document"),
+  document: HMDocumentSchema,
+  id: unpackedHmIdSchema
+});
+var HMResourceCommentSchema = z.object({
+  type: z.literal("comment"),
+  comment: HMCommentSchema,
+  id: unpackedHmIdSchema
+});
+var HMResourceRedirectSchema = z.object({
+  type: z.literal("redirect"),
+  id: unpackedHmIdSchema,
+  redirectTarget: unpackedHmIdSchema
+});
+var HMResourceNotFoundSchema = z.object({
+  type: z.literal("not-found"),
+  id: unpackedHmIdSchema
+});
+var HMResourceTombstoneSchema = z.object({
+  type: z.literal("tombstone"),
+  id: unpackedHmIdSchema
+});
+var HMResourceErrorSchema = z.object({
+  type: z.literal("error"),
+  id: unpackedHmIdSchema,
+  message: z.string()
+});
+var HMResourceSchema = z.discriminatedUnion("type", [
+  HMResourceDocumentSchema,
+  HMResourceCommentSchema,
+  // todo: Contact, Capability
+  HMResourceRedirectSchema,
+  // what if there is a profile ALIAS? how is that different from a home doc redirect?
+  HMResourceNotFoundSchema,
+  HMResourceTombstoneSchema,
+  HMResourceErrorSchema
+]);
+var HMResolvedResourceSchema = z.discriminatedUnion("type", [
+  HMResourceDocumentSchema,
+  HMResourceCommentSchema,
+  HMResourceTombstoneSchema
+]);
+var HMContactRecordSchema = z.object({
+  id: z.string(),
+  subject: z.string(),
+  name: z.string(),
+  account: z.string(),
+  createTime: HMTimestampSchema.optional(),
+  updateTime: HMTimestampSchema.optional()
+});
+var HMAccountContactsRequestSchema = z.object({
+  key: z.literal("AccountContacts"),
+  input: z.string(),
+  // account UID
+  output: z.array(HMContactRecordSchema)
+});
+var HMSubjectContactsRequestSchema = z.object({
+  key: z.literal("SubjectContacts"),
+  input: z.string(),
+  // subject UID
+  output: z.array(HMContactRecordSchema)
+});
+var HMResourceRequestSchema = z.object({
+  key: z.literal("Resource"),
+  input: unpackedHmIdSchema,
+  output: HMResourceSchema
+});
+var HMResourceMetadataRequestSchema = z.object({
+  key: z.literal("ResourceMetadata"),
+  input: unpackedHmIdSchema,
+  output: HMMetadataPayloadSchema
+});
+var HMAccountRequestSchema = z.object({
+  key: z.literal("Account"),
+  input: z.string(),
+  output: HMAccountResultSchema
+});
+var HMCommentRequestSchema = z.object({
+  key: z.literal("Comment"),
+  input: z.string(),
+  output: HMCommentSchema
+});
+var HMSearchInputSchema = z.object({
+  query: z.string(),
+  accountUid: z.string().optional(),
+  includeBody: z.boolean().optional(),
+  contextSize: z.number().optional(),
+  perspectiveAccountUid: z.string().optional(),
+  searchType: z.number().optional()
+});
+var HMSearchResultItemSchema = z.object({
+  id: unpackedHmIdSchema,
+  metadata: HMDocumentMetadataSchema.optional(),
+  title: z.string(),
+  icon: z.string(),
+  parentNames: z.array(z.string()),
+  versionTime: z.any().optional(),
+  searchQuery: z.string(),
+  type: z.enum(["document", "contact"])
+});
+var HMSearchPayloadSchema = z.object({
+  entities: z.array(HMSearchResultItemSchema),
+  searchQuery: z.string()
+});
+var HMSearchRequestSchema = z.object({
+  key: z.literal("Search"),
+  input: HMSearchInputSchema,
+  output: HMSearchPayloadSchema
+});
+var HMQueryRequestSchema = z.object({
+  key: z.literal("Query"),
+  input: HMQuerySchema,
+  output: HMQueryResultSchema.nullable()
+});
+var HMListCommentsInputSchema = z.object({
+  targetId: unpackedHmIdSchema
+});
+var HMListCommentsOutputSchema = z.object({
+  comments: z.array(HMCommentSchema),
+  authors: z.record(z.string(), HMMetadataPayloadSchema)
+});
+var HMListCommentsRequestSchema = z.object({
+  key: z.literal("ListComments"),
+  input: HMListCommentsInputSchema,
+  output: HMListCommentsOutputSchema
+});
+var HMListDiscussionsInputSchema = z.object({
+  targetId: unpackedHmIdSchema,
+  commentId: z.string().optional()
+});
+var HMListDiscussionsOutputSchema = z.object({
+  discussions: z.array(HMCommentGroupSchema),
+  authors: z.record(z.string(), HMMetadataPayloadSchema),
+  citingDiscussions: z.array(HMExternalCommentGroupSchema)
+});
+var HMListDiscussionsRequestSchema = z.object({
+  key: z.literal("ListDiscussions"),
+  input: HMListDiscussionsInputSchema,
+  output: HMListDiscussionsOutputSchema
+});
+var HMListCommentsByReferenceInputSchema = z.object({
+  targetId: unpackedHmIdSchema
+});
+var HMListCommentsByReferenceRequestSchema = z.object({
+  key: z.literal("ListCommentsByReference"),
+  input: HMListCommentsByReferenceInputSchema,
+  output: HMListCommentsOutputSchema
+});
+var HMGetCommentReplyCountInputSchema = z.object({
+  id: z.string()
+});
+var HMGetCommentReplyCountRequestSchema = z.object({
+  key: z.literal("GetCommentReplyCount"),
+  input: HMGetCommentReplyCountInputSchema,
+  output: z.number()
+});
+var HMListEventsInputSchema = z.object({
+  pageSize: z.number().optional(),
+  pageToken: z.string().optional(),
+  trustedOnly: z.boolean().optional(),
+  filterAuthors: z.array(z.string()).optional(),
+  filterEventType: z.array(z.string()).optional(),
+  filterResource: z.string().optional(),
+  currentAccount: z.string().optional()
+});
+var HMLoadedEventSchema = z.object({}).passthrough();
+var HMListEventsOutputSchema = z.object({
+  events: z.array(HMLoadedEventSchema),
+  nextPageToken: z.string()
+});
+var HMListEventsRequestSchema = z.object({
+  key: z.literal("ListEvents"),
+  input: HMListEventsInputSchema,
+  output: HMListEventsOutputSchema
+});
+var HMListAccountsOutputSchema = z.object({
+  accounts: z.array(HMMetadataPayloadSchema)
+});
+var HMListAccountsInputSchema = z.object({}).optional();
+var HMListAccountsRequestSchema = z.object({
+  key: z.literal("ListAccounts"),
+  input: HMListAccountsInputSchema,
+  output: HMListAccountsOutputSchema
+});
+var HMGetCIDOutputSchema = z.object({
+  value: z.any()
+});
+var HMGetCIDInputSchema = z.object({
+  cid: z.string()
+});
+var HMGetCIDRequestSchema = z.object({
+  key: z.literal("GetCID"),
+  input: HMGetCIDInputSchema,
+  output: HMGetCIDOutputSchema
+});
+var HMListCommentsByAuthorOutputSchema = z.object({
+  comments: z.array(HMCommentSchema),
+  authors: z.record(z.string(), HMMetadataPayloadSchema)
+});
+var HMListCommentsByAuthorInputSchema = z.object({
+  authorId: unpackedHmIdSchema
+});
+var HMListCommentsByAuthorRequestSchema = z.object({
+  key: z.literal("ListCommentsByAuthor"),
+  input: HMListCommentsByAuthorInputSchema,
+  output: HMListCommentsByAuthorOutputSchema
+});
+var HMRawMentionSchema = z.object({
+  source: z.string(),
+  sourceType: z.string().optional(),
+  sourceDocument: z.string().optional(),
+  targetFragment: z.string().optional(),
+  isExact: z.boolean().optional()
+});
+var HMListCitationsOutputSchema = z.object({
+  citations: z.array(HMRawMentionSchema)
+});
+var HMListCitationsInputSchema = z.object({
+  targetId: unpackedHmIdSchema
+});
+var HMListCitationsRequestSchema = z.object({
+  key: z.literal("ListCitations"),
+  input: HMListCitationsInputSchema,
+  output: HMListCitationsOutputSchema
+});
+var HMRawDocumentChangeSchema = z.object({
+  id: z.string().optional(),
+  author: z.string().optional(),
+  deps: z.array(z.string()).optional(),
+  createTime: z.string().optional()
+});
+var HMListChangesOutputSchema = z.object({
+  changes: z.array(HMRawDocumentChangeSchema),
+  latestVersion: z.string().optional()
+});
+var HMListChangesInputSchema = z.object({
+  targetId: unpackedHmIdSchema
+});
+var HMListChangesRequestSchema = z.object({
+  key: z.literal("ListChanges"),
+  input: HMListChangesInputSchema,
+  output: HMListChangesOutputSchema
+});
+var HMRawCapabilitySchema = z.object({
+  id: z.string().optional(),
+  issuer: z.string().optional(),
+  delegate: z.string().optional(),
+  account: z.string().optional(),
+  path: z.string().optional(),
+  role: z.string().optional(),
+  noRecursive: z.boolean().optional(),
+  label: z.string().optional(),
+  createTime: z.string().optional()
+});
+var HMListCapabilitiesOutputSchema = z.object({
+  capabilities: z.array(HMRawCapabilitySchema)
+});
+var HMListCapabilitiesInputSchema = z.object({
+  targetId: unpackedHmIdSchema
+});
+var HMListCapabilitiesRequestSchema = z.object({
+  key: z.literal("ListCapabilities"),
+  input: HMListCapabilitiesInputSchema,
+  output: HMListCapabilitiesOutputSchema
+});
+var HMInteractionSummaryInputSchema = z.object({
+  id: unpackedHmIdSchema
+});
+var HMInteractionSummaryOutputSchema = z.object({
+  citations: z.number(),
+  comments: z.number(),
+  changes: z.number(),
+  children: z.number(),
+  blocks: z.record(
+    z.string(),
+    z.object({
+      citations: z.number(),
+      comments: z.number()
+    })
+  )
+});
+var HMInteractionSummaryRequestSchema = z.object({
+  key: z.literal("InteractionSummary"),
+  input: HMInteractionSummaryInputSchema,
+  output: HMInteractionSummaryOutputSchema
+});
+var HMPublishBlobsOutputSchema = z.object({
+  cids: z.array(z.string())
+});
+var HMPublishBlobsInputSchema = z.object({
+  blobs: z.array(
+    z.object({
+      cid: z.string().optional(),
+      data: z.custom((val) => ArrayBuffer.isView(val) && "byteLength" in val, {
+        message: "Expected Uint8Array or compatible binary data"
+      })
+    })
+  )
+});
+var HMPublishBlobsRequestSchema = z.object({
+  key: z.literal("PublishBlobs"),
+  input: HMPublishBlobsInputSchema,
+  output: HMPublishBlobsOutputSchema
+});
+var ProtoAnnotationSchema = z.object({
+  type: z.string(),
+  link: z.string().optional(),
+  attributes: z.record(z.string(), z.any()).optional(),
+  starts: z.array(z.number()).optional(),
+  ends: z.array(z.number()).optional()
+});
+var ProtoBlockSchema = z.object({
+  id: z.string().optional(),
+  type: z.string().optional(),
+  text: z.string().optional(),
+  link: z.string().optional(),
+  attributes: z.record(z.string(), z.any()).optional(),
+  annotations: z.array(ProtoAnnotationSchema).optional(),
+  revision: z.string().optional()
+});
+var ProtoSetAttributeValueSchema = z.union([
+  z.object({ case: z.literal("stringValue"), value: z.string() }),
+  z.object({ case: z.literal("intValue"), value: z.union([z.bigint(), z.coerce.bigint()]) }),
+  z.object({ case: z.literal("boolValue"), value: z.boolean() }),
+  z.object({ case: z.literal("nullValue"), value: z.object({}) }),
+  z.object({ case: z.undefined(), value: z.undefined().optional() })
+]);
+var ProtoDocumentChangeSchema = z.object({
+  op: z.union([
+    z.object({ case: z.literal("setMetadata"), value: z.object({ key: z.string(), value: z.string() }) }),
+    z.object({
+      case: z.literal("moveBlock"),
+      value: z.object({ blockId: z.string(), parent: z.string(), leftSibling: z.string() })
+    }),
+    z.object({ case: z.literal("replaceBlock"), value: ProtoBlockSchema }),
+    z.object({ case: z.literal("deleteBlock"), value: z.string() }),
+    z.object({
+      case: z.literal("setAttribute"),
+      value: z.object({ blockId: z.string(), key: z.array(z.string()), value: ProtoSetAttributeValueSchema })
+    }),
+    z.object({ case: z.undefined(), value: z.undefined().optional() })
+  ])
+});
+var HMPrepareDocumentChangeInputSchema = z.object({
+  account: z.string(),
+  path: z.string().optional(),
+  baseVersion: z.string().optional(),
+  changes: z.array(ProtoDocumentChangeSchema),
+  capability: z.string().optional(),
+  visibility: z.number().int().optional()
+});
+var HMPrepareDocumentChangeOutputSchema = z.object({
+  unsignedChange: z.custom((val) => ArrayBuffer.isView(val) && "byteLength" in val, {
+    message: "Expected Uint8Array or compatible binary data"
+  })
+});
+var HMPrepareDocumentChangeRequestSchema = z.object({
+  key: z.literal("PrepareDocumentChange"),
+  input: HMPrepareDocumentChangeInputSchema,
+  output: HMPrepareDocumentChangeOutputSchema
+});
+var HMGetRequestSchema = z.discriminatedUnion("key", [
+  HMResourceRequestSchema,
+  HMResourceMetadataRequestSchema,
+  HMAccountRequestSchema,
+  HMCommentRequestSchema,
+  HMSearchRequestSchema,
+  HMQueryRequestSchema,
+  HMAccountContactsRequestSchema,
+  HMSubjectContactsRequestSchema,
+  HMListCommentsRequestSchema,
+  HMListDiscussionsRequestSchema,
+  HMListCommentsByReferenceRequestSchema,
+  HMGetCommentReplyCountRequestSchema,
+  HMListEventsRequestSchema,
+  HMListAccountsRequestSchema,
+  HMGetCIDRequestSchema,
+  HMListCommentsByAuthorRequestSchema,
+  HMListCitationsRequestSchema,
+  HMListChangesRequestSchema,
+  HMListCapabilitiesRequestSchema,
+  HMInteractionSummaryRequestSchema
+]);
+var HMActionSchema = z.discriminatedUnion("key", [
+  HMPublishBlobsRequestSchema,
+  HMPrepareDocumentChangeRequestSchema
+]);
+var HMRequestSchema = z.discriminatedUnion("key", [
+  HMResourceRequestSchema,
+  HMResourceMetadataRequestSchema,
+  HMAccountRequestSchema,
+  HMCommentRequestSchema,
+  HMSearchRequestSchema,
+  HMQueryRequestSchema,
+  HMAccountContactsRequestSchema,
+  HMSubjectContactsRequestSchema,
+  HMListCommentsRequestSchema,
+  HMListDiscussionsRequestSchema,
+  HMListCommentsByReferenceRequestSchema,
+  HMGetCommentReplyCountRequestSchema,
+  HMListEventsRequestSchema,
+  HMListAccountsRequestSchema,
+  HMGetCIDRequestSchema,
+  HMListCommentsByAuthorRequestSchema,
+  HMListCitationsRequestSchema,
+  HMListChangesRequestSchema,
+  HMListCapabilitiesRequestSchema,
+  HMInteractionSummaryRequestSchema,
+  HMPublishBlobsRequestSchema,
+  HMPrepareDocumentChangeRequestSchema
+]);
+var HYPERMEDIA_SCHEME = "hm";
+function packBaseId(uid, path) {
+  const filteredPath = (path == null ? void 0 : path.filter((p) => p !== "")) || [];
+  const restPath = filteredPath.length ? `/${filteredPath.join("/")}` : "";
+  return `${HYPERMEDIA_SCHEME}://${uid}${restPath}`;
+}
+function packHmId(hmId) {
+  const { path, version, latest, blockRef, blockRange, uid } = hmId;
+  if (!uid) throw new Error("uid is required");
+  let responseUrl = packBaseId(uid, path);
+  responseUrl += getHMQueryString({
+    version,
+    latest
+  });
+  if (blockRef) {
+    responseUrl += `#${blockRef}${serializeBlockRange(blockRange)}`;
+  }
+  return responseUrl;
+}
+function getHMQueryString({
+  version,
+  latest,
+  panel
+}) {
+  const query = {};
+  if (version) {
+    query.v = version;
+  }
+  if (latest) {
+    query.l = null;
+  }
+  if (panel) {
+    query.panel = panel;
+  }
+  return serializeHmQueryString(query);
+}
+function serializeBlockRange(range) {
+  let res = "";
+  if (range) {
+    if ("expanded" in range && range.expanded) {
+      res += "+";
+    } else if ("start" in range) {
+      res += `[${range.start}:${range.end}]`;
+    }
+  }
+  return res;
+}
+function serializeHmQueryString(query) {
+  const queryString = Object.entries(query).map(([key, value]) => value === null ? key : `${key}=${value}`).join("&");
+  if (!queryString) return "";
+  return `?${queryString}`;
+}
+function hmIdPathToEntityQueryPath(path) {
+  const filteredPath = path == null ? void 0 : path.filter((term) => !!term);
+  return (filteredPath == null ? void 0 : filteredPath.length) ? `/${filteredPath.join("/")}` : "";
+}
+function entityQueryPathToHmIdPath(path) {
+  if (!path) return [];
+  if (path === "/") return [];
+  return path.split("/").filter(Boolean);
+}
+
+export {
+  BlockRangeSchema,
+  unpackedHmIdSchema,
+  HMBlockChildrenTypeSchema,
+  HMEmbedViewSchema,
+  HMQueryStyleSchema,
+  BoldAnnotationSchema,
+  ItalicAnnotationSchema,
+  UnderlineAnnotationSchema,
+  StrikeAnnotationSchema,
+  CodeAnnotationSchema,
+  LinkAnnotationSchema,
+  InlineEmbedAnnotationSchema,
+  HighlightAnnotationSchema,
+  HMAnnotationSchema,
+  HMAnnotationsSchema,
+  HMBlockParagraphSchema,
+  HMBlockHeadingSchema,
+  HMBlockCodeSchema,
+  HMBlockMathSchema,
+  toNumber,
+  HMBlockImageSchema,
+  HMBlockVideoSchema,
+  HMBlockFileSchema,
+  HMBlockButtonAlignmentSchema,
+  HMBlockButtonSchema,
+  HMBlockEmbedSchema,
+  HMBlockWebEmbedSchema,
+  HMBlockNostrSchema,
+  HMTimestampSchema,
+  HMBlockNodeSchema,
+  HMDocumentMetadataSchema,
+  hmMetadataJsonCorrection,
+  HMResourceVisibilitySchema,
+  HMCommentSchema,
+  HMBreadcrumbSchema,
+  HMCommentGroupSchema,
+  HMExternalCommentGroupSchema,
+  HMActivitySummarySchema,
+  HMGenerationInfoSchema,
+  HMRedirectInfoSchema,
+  HMDocumentInfoSchema,
+  HMQueryResultSchema,
+  HMRoleSchema,
+  HMMetadataPayloadSchema,
+  HMAccountPayloadSchema,
+  HMAccountNotFoundSchema,
+  HMAccountResultSchema,
+  HMAccountsMetadataSchema,
+  HMQueryInclusionSchema,
+  HMQuerySortSchema,
+  HMQuerySchema,
+  HMBlockQuerySchema,
+  HMBlockGroupSchema,
+  HMBlockLinkSchema,
+  HMBlockKnownSchema,
+  HMBlockUnknownSchema,
+  HMBlockSchema,
+  knownBlockTypes,
+  isKnownBlockType,
+  HMDocumentSchema,
+  HMResourceDocumentSchema,
+  HMResourceCommentSchema,
+  HMResourceRedirectSchema,
+  HMResourceNotFoundSchema,
+  HMResourceTombstoneSchema,
+  HMResourceErrorSchema,
+  HMResourceSchema,
+  HMResolvedResourceSchema,
+  HMContactRecordSchema,
+  HMAccountContactsRequestSchema,
+  HMSubjectContactsRequestSchema,
+  HMResourceRequestSchema,
+  HMResourceMetadataRequestSchema,
+  HMAccountRequestSchema,
+  HMCommentRequestSchema,
+  HMSearchInputSchema,
+  HMSearchResultItemSchema,
+  HMSearchPayloadSchema,
+  HMSearchRequestSchema,
+  HMQueryRequestSchema,
+  HMListCommentsInputSchema,
+  HMListCommentsOutputSchema,
+  HMListCommentsRequestSchema,
+  HMListDiscussionsInputSchema,
+  HMListDiscussionsOutputSchema,
+  HMListDiscussionsRequestSchema,
+  HMListCommentsByReferenceInputSchema,
+  HMListCommentsByReferenceRequestSchema,
+  HMGetCommentReplyCountInputSchema,
+  HMGetCommentReplyCountRequestSchema,
+  HMListEventsInputSchema,
+  HMLoadedEventSchema,
+  HMListEventsOutputSchema,
+  HMListEventsRequestSchema,
+  HMListAccountsOutputSchema,
+  HMListAccountsInputSchema,
+  HMListAccountsRequestSchema,
+  HMGetCIDOutputSchema,
+  HMGetCIDInputSchema,
+  HMGetCIDRequestSchema,
+  HMListCommentsByAuthorOutputSchema,
+  HMListCommentsByAuthorInputSchema,
+  HMListCommentsByAuthorRequestSchema,
+  HMRawMentionSchema,
+  HMListCitationsOutputSchema,
+  HMListCitationsInputSchema,
+  HMListCitationsRequestSchema,
+  HMRawDocumentChangeSchema,
+  HMListChangesOutputSchema,
+  HMListChangesInputSchema,
+  HMListChangesRequestSchema,
+  HMRawCapabilitySchema,
+  HMListCapabilitiesOutputSchema,
+  HMListCapabilitiesInputSchema,
+  HMListCapabilitiesRequestSchema,
+  HMInteractionSummaryInputSchema,
+  HMInteractionSummaryOutputSchema,
+  HMInteractionSummaryRequestSchema,
+  HMPublishBlobsOutputSchema,
+  HMPublishBlobsInputSchema,
+  HMPublishBlobsRequestSchema,
+  HMPrepareDocumentChangeInputSchema,
+  HMPrepareDocumentChangeOutputSchema,
+  HMPrepareDocumentChangeRequestSchema,
+  HMGetRequestSchema,
+  HMActionSchema,
+  HMRequestSchema,
+  HYPERMEDIA_SCHEME,
+  packBaseId,
+  packHmId,
+  getHMQueryString,
+  serializeBlockRange,
+  hmIdPathToEntityQueryPath,
+  entityQueryPathToHmIdPath
+};