an.era 0.3.0-beta

package/dist/index.js

@@ -0,0 +1,1233 @@
+import { t as __exportAll } from "./chunk-BN_g-Awi.js";
+import * as v from "valibot";
+
+//#region src/openapi/components/schemas.ts
+const ErrorSchema = v.required(v.partial(v.object({
+	error: v.pipe(v.string(), v.metadata({ description: "Error message" }), v.examples(["Not Found"])),
+	code: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "HTTP status code" }), v.examples([404])),
+	details: v.pipe(v.object({ message: v.pipe(v.string(), v.metadata({ description: "Detailed error message" }), v.examples(["The resource you are looking for does not exist."])) }), v.metadata({ description: "Additional error details" }))
+})), ["error", "code"]);
+const RateLimitErrorSchema = v.pipe(v.required(v.object({ error: v.required(v.partial(v.object({
+	type: v.pipe(v.string(), v.metadata({ description: "Error type identifier" }), v.examples(["rate_limit_exceeded"])),
+	message: v.pipe(v.string(), v.metadata({ description: "Human-readable error message" }), v.examples(["Rate limit of 30 requests per minute exceeded for guest tier. Try again later."])),
+	tier: v.pipe(v.picklist([
+		"guest",
+		"free",
+		"premium",
+		"supporter"
+	]), v.metadata({ description: "User's current tier" }), v.examples(["guest"])),
+	limit: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Request limit per minute for this tier" }), v.examples([30])),
+	limit_window: v.pipe(v.string(), v.metadata({ description: "Time window for rate limits" }), v.examples(["1 minute"])),
+	retry_after: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Suggested seconds to wait before retrying" }), v.examples([65])),
+	current_status: v.object({
+		tier: v.pipe(v.string(), v.examples(["guest"])),
+		limits: v.pipe(v.record(v.string(), v.union([v.number()])), v.examples([{
+			"guest": 30,
+			"free": 120,
+			"premium": 300,
+			"supporter": 600
+		}])),
+		upgrade_path: v.object({
+			current: v.pipe(v.string(), v.examples(["Guest (30 req/min)"])),
+			recommended: v.pipe(v.string(), v.examples(["Free Account (120 req/min)"])),
+			benefits: v.pipe(v.array(v.string()), v.examples([[
+				"4x higher rate limit",
+				"Persistent authentication",
+				"API access"
+			]])),
+			action: v.pipe(v.string(), v.examples(["Sign up at https://are.na/signup"]))
+		})
+	}),
+	suggestions: v.pipe(v.array(v.string()), v.metadata({ description: "Tier-specific optimization suggestions" }), v.examples([[
+		"Sign up for a free account to get 120 requests per minute",
+		"Implement exponential backoff with jitter",
+		"Cache responses when possible to reduce API calls",
+		"Consider batch requests if available"
+	]])),
+	headers_note: v.pipe(v.string(), v.metadata({ description: "Information about header usage" }), v.examples(["Check 'X-RateLimit-*' headers on successful requests for current usage"]))
+})), [
+	"type",
+	"message",
+	"tier",
+	"limit",
+	"retry_after",
+	"suggestions"
+]) }), ["error"]), v.metadata({ description: "Rate limit exceeded error response with upgrade information and suggestions" }));
+const LinkSchema = v.pipe(v.required(v.object({ href: v.pipe(v.string(), v.metadata({ description: "The URL of the linked resource" }), v.examples(["https://api.are.na/v3/blocks/12345"])) }), ["href"]), v.metadata({ description: "A hypermedia link containing the URL of a linked resource.\nThe relationship type is expressed by the key in the parent _links object.\n" }));
+const MarkdownContentSchema = v.pipe(v.required(v.object({
+	markdown: v.pipe(v.string(), v.metadata({ description: "Original markdown value" }), v.examples(["This is **only** a [test](https://example.com)."])),
+	html: v.pipe(v.string(), v.metadata({ description: "HTML rendering of the markdown" }), v.examples(["<p>This is <strong>only</strong> a <a href=\"https://example.com\" target=\"_blank\" rel=\"nofollow noopener\">test</a>.</p>"])),
+	plain: v.pipe(v.string(), v.metadata({ description: "Plain text rendering of the markdown" }), v.examples(["This is only a test (https://example.com)."]))
+}), [
+	"markdown",
+	"html",
+	"plain"
+]), v.metadata({ description: "Markdown content with multiple renderings" }));
+const EmbeddedUserSchema = v.pipe(v.required(v.object({
+	id: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Unique identifier for the user" }), v.examples([12345])),
+	type: v.pipe(v.picklist(["User"]), v.metadata({ description: "User type" }), v.examples(["User"])),
+	name: v.pipe(v.string(), v.metadata({ description: "User's display name" }), v.examples(["John Doe"])),
+	slug: v.pipe(v.string(), v.metadata({ description: "URL-safe identifier (use this in API paths)" }), v.examples(["john-doe"])),
+	avatar: v.pipe(v.union([
+		v.string(),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "URL to user's avatar image" }), v.examples(["https://d2w9rnfcy7mm78.cloudfront.net/12345/avatar.jpg"])),
+	initials: v.pipe(v.string(), v.metadata({ description: "User's initials" }), v.examples(["JD"]))
+}), [
+	"id",
+	"type",
+	"name",
+	"slug",
+	"avatar",
+	"initials"
+]), v.metadata({ description: "Embedded user representation (used when user is nested in other resources)" }));
+const EmbeddedGroupSchema = v.pipe(v.required(v.object({
+	id: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Unique identifier for the group" }), v.examples([67890])),
+	type: v.pipe(v.picklist(["Group"]), v.metadata({ description: "Group type" }), v.examples(["Group"])),
+	name: v.pipe(v.string(), v.metadata({ description: "Group's name" }), v.examples(["Design Team"])),
+	slug: v.pipe(v.string(), v.metadata({ description: "Group's URL slug" }), v.examples(["design-team-abc123"])),
+	avatar: v.pipe(v.union([
+		v.string(),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "URL to group's avatar image" }), v.examples(["https://d2w9rnfcy7mm78.cloudfront.net/groups/67890/avatar.jpg"])),
+	initials: v.pipe(v.string(), v.metadata({ description: "Group's initials" }), v.examples(["DT"]))
+}), [
+	"id",
+	"type",
+	"name",
+	"slug",
+	"avatar",
+	"initials"
+]), v.metadata({ description: "Embedded group representation (used when group is nested in other resources)" }));
+const UserCountsSchema = v.pipe(v.required(v.object({
+	channels: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Number of channels owned by the user" }), v.examples([24])),
+	followers: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Number of followers" }), v.examples([156])),
+	following: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Number of users being followed" }), v.examples([89]))
+}), [
+	"channels",
+	"followers",
+	"following"
+]), v.metadata({ description: "Counts of various items for the user" }));
+const GroupCountsSchema = v.pipe(v.required(v.object({
+	channels: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Number of channels owned by the group" }), v.examples([12])),
+	users: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Number of users in the group" }), v.examples([5]))
+}), ["channels", "users"]), v.metadata({ description: "Counts of various items for the group" }));
+const ContentTypeFilterSchema = v.pipe(v.picklist([
+	"Text",
+	"Image",
+	"Link",
+	"Attachment",
+	"Embed",
+	"Channel",
+	"Block"
+]), v.metadata({ description: "Filter for content types (blocks and channels)" }));
+const SearchTypeFilterSchema = v.pipe(v.picklist([
+	"All",
+	"Text",
+	"Image",
+	"Link",
+	"Attachment",
+	"Embed",
+	"Channel",
+	"Block",
+	"User",
+	"Group"
+]), v.metadata({ description: "Filter for searchable content types (includes all content types plus users and groups)" }));
+const FileExtensionSchema = v.pipe(v.picklist([
+	"aac",
+	"ai",
+	"aiff",
+	"avi",
+	"avif",
+	"bmp",
+	"csv",
+	"doc",
+	"docx",
+	"eps",
+	"epub",
+	"fla",
+	"gif",
+	"h264",
+	"heic",
+	"heif",
+	"ind",
+	"indd",
+	"jpeg",
+	"jpg",
+	"key",
+	"kml",
+	"kmz",
+	"latex",
+	"m4a",
+	"ma",
+	"mb",
+	"mid",
+	"midi",
+	"mov",
+	"mp3",
+	"mp4",
+	"mp4v",
+	"mpeg",
+	"mpg",
+	"mpg4",
+	"numbers",
+	"oga",
+	"ogg",
+	"ogv",
+	"otf",
+	"pages",
+	"pdf",
+	"pgp",
+	"png",
+	"ppt",
+	"pptx",
+	"psd",
+	"svg",
+	"swa",
+	"swf",
+	"tex",
+	"texi",
+	"texinfo",
+	"tfm",
+	"tif",
+	"tiff",
+	"torrent",
+	"ttc",
+	"ttf",
+	"txt",
+	"wav",
+	"webm",
+	"webp",
+	"wma",
+	"xls",
+	"xlsx",
+	"xlt"
+]), v.metadata({ description: "Supported file extensions for filtering" }));
+const ConnectionSortSchema = v.pipe(v.picklist(["created_at_desc", "created_at_asc"]), v.metadata({ description: "Sort order for connection lists (channels containing a block/channel, followers)" }));
+const ChannelContentSortSchema = v.pipe(v.picklist([
+	"position_asc",
+	"position_desc",
+	"created_at_asc",
+	"created_at_desc",
+	"updated_at_asc",
+	"updated_at_desc"
+]), v.metadata({ description: "Sort order for channel contents (includes position for manual ordering)" }));
+const ContentSortSchema = v.pipe(v.picklist([
+	"created_at_asc",
+	"created_at_desc",
+	"updated_at_asc",
+	"updated_at_desc"
+]), v.metadata({ description: "Sort order for user/group content lists" }));
+const BlockProviderSchema = v.required(v.object({
+	name: v.pipe(v.string(), v.metadata({ description: "Provider name (from parsed URI host)" }), v.examples(["Example.com"])),
+	url: v.pipe(v.string(), v.metadata({ description: "Provider URL (from parsed URI scheme and host)" }), v.examples(["https://example.com"]))
+}), ["name", "url"]);
+const ImageVersionSchema = v.pipe(v.required(v.partial(v.object({
+	src: v.pipe(v.string(), v.metadata({ description: "Default image URL (1x resolution)" }), v.examples(["https://d2w9rnfcy7mm78.cloudfront.net/12345/display_image.jpg"])),
+	src_1x: v.pipe(v.string(), v.metadata({ description: "1x resolution image URL" }), v.examples(["https://d2w9rnfcy7mm78.cloudfront.net/12345/display_image.jpg"])),
+	src_2x: v.pipe(v.string(), v.metadata({ description: "2x resolution image URL for high DPI displays" }), v.examples(["https://d2w9rnfcy7mm78.cloudfront.net/12345/display_image@2x.jpg"])),
+	width: v.pipe(v.union([
+		v.pipe(v.number(), v.integer()),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Width of the resized image in pixels" }), v.examples([640])),
+	height: v.pipe(v.union([
+		v.pipe(v.number(), v.integer()),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Height of the resized image in pixels" }), v.examples([480]))
+})), [
+	"src",
+	"src_1x",
+	"src_2x"
+]), v.metadata({ description: "A resized/processed version of an image with multiple resolution URLs" }));
+const BlockEmbedSchema = v.object({
+	url: v.pipe(v.union([
+		v.string(),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Embed URL" }), v.examples(["https://www.youtube.com/embed/abc123"])),
+	type: v.pipe(v.union([
+		v.string(),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Embed type" }), v.examples(["youtube"])),
+	title: v.pipe(v.union([
+		v.string(),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Embed title" }), v.examples(["Video Title"])),
+	author_name: v.pipe(v.union([
+		v.string(),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Author name" }), v.examples(["Author Name"])),
+	author_url: v.pipe(v.union([
+		v.string(),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Author URL" }), v.examples(["https://example.com/author"])),
+	source_url: v.pipe(v.union([
+		v.string(),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Embed source URL" }), v.examples(["https://www.youtube.com/watch?v=abc123"])),
+	width: v.pipe(v.union([
+		v.pipe(v.number(), v.integer()),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Embed width" }), v.examples([640])),
+	height: v.pipe(v.union([
+		v.pipe(v.number(), v.integer()),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Embed height" }), v.examples([480])),
+	html: v.pipe(v.union([
+		v.string(),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Embed HTML" }), v.examples(["<iframe src='...'></iframe>"])),
+	thumbnail_url: v.pipe(v.union([
+		v.string(),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Thumbnail URL" }), v.examples(["https://example.com/thumbnail.jpg"]))
+});
+const BlockAttachmentSchema = v.required(v.partial(v.object({
+	filename: v.pipe(v.union([
+		v.string(),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Attachment filename" }), v.examples(["document.pdf"])),
+	content_type: v.pipe(v.union([
+		v.string(),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Attachment content type" }), v.examples(["application/pdf"])),
+	file_size: v.pipe(v.union([
+		v.pipe(v.number(), v.integer()),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "File size in bytes" }), v.examples([2048e3])),
+	file_extension: v.pipe(v.union([
+		v.string(),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "File extension" }), v.examples(["pdf"])),
+	updated_at: v.pipe(v.union([
+		v.string(),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "When the attachment was last updated" })),
+	url: v.pipe(v.string(), v.metadata({ description: "Attachment download URL" }), v.examples(["https://attachments.are.na/12345/document.pdf"]))
+})), ["url"]);
+const ChannelCountsSchema = v.pipe(v.required(v.object({
+	blocks: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Number of blocks in the channel" }), v.examples([42])),
+	channels: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Number of channels connected to this channel" }), v.examples([8])),
+	contents: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Total number of contents (blocks + channels)" }), v.examples([50])),
+	collaborators: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Number of collaborators on the channel" }), v.examples([3]))
+}), [
+	"blocks",
+	"channels",
+	"contents",
+	"collaborators"
+]), v.metadata({ description: "Counts of various items in the channel" }));
+const PaginationMetaWithCountSchema = v.pipe(v.required(v.partial(v.object({
+	current_page: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Current page number" }), v.examples([1])),
+	next_page: v.pipe(v.union([
+		v.pipe(v.number(), v.integer()),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Next page number (null if last page)" }), v.examples([2])),
+	prev_page: v.pipe(v.union([
+		v.pipe(v.number(), v.integer()),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Previous page number (null if first page)" })),
+	per_page: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Number of items per page" }), v.examples([25])),
+	total_pages: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Total number of pages available" }), v.examples([5])),
+	total_count: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Total number of items available" }), v.examples([120])),
+	has_more_pages: v.pipe(v.boolean(), v.metadata({ description: "Whether there are more pages available" }), v.examples([true]))
+})), [
+	"current_page",
+	"per_page",
+	"total_pages",
+	"total_count",
+	"has_more_pages"
+]), v.metadata({ description: "Pagination metadata when total counts are available" }));
+const PaginationMetaWithoutCountSchema = v.pipe(v.required(v.partial(v.object({
+	current_page: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Current page number" }), v.examples([1])),
+	next_page: v.pipe(v.union([
+		v.pipe(v.number(), v.integer()),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Next page number (null if last page)" }), v.examples([2])),
+	prev_page: v.pipe(v.union([
+		v.pipe(v.number(), v.integer()),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Previous page number (null if first page)" })),
+	per_page: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Number of items per page" }), v.examples([25])),
+	has_more_pages: v.pipe(v.boolean(), v.metadata({ description: "Whether there are more pages available" }), v.examples([true]))
+})), [
+	"current_page",
+	"per_page",
+	"has_more_pages"
+]), v.metadata({ description: "Pagination metadata when total counts are not available" }));
+const PingResponseSchema = v.pipe(v.required(v.object({ status: v.pipe(v.picklist(["ok"]), v.examples(["ok"])) }), ["status"]), v.metadata({ description: "Health check response" }));
+const LinksSchema = v.pipe(v.required(v.object({ self: v.intersect([LinkSchema, v.pipe(v.any(), v.metadata({ description: "Link to the current resource (always present)" }))]) }), ["self"]), v.metadata({ description: "HATEOAS links for navigation and discovery.\nFollows HAL (Hypertext Application Language) format where link relationships \nare expressed as object keys (e.g., \"self\", \"user\", \"channels\").\n" }));
+const ConnectionContextSchema = v.pipe(v.required(v.object({
+	id: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Unique identifier for the connection" }), v.examples([98765])),
+	position: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Position of the item within the channel (for manual ordering)" }), v.examples([1])),
+	pinned: v.pipe(v.boolean(), v.metadata({ description: "Whether the item is pinned to the top of the channel" }), v.examples([false])),
+	connected_at: v.pipe(v.string(), v.metadata({ description: "When the item was connected to the channel" }), v.examples(["2023-01-15T10:30:00Z"])),
+	connected_by: v.pipe(v.union([
+		EmbeddedUserSchema,
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "User who connected this item to the channel" }))
+}), [
+	"id",
+	"position",
+	"pinned",
+	"connected_at",
+	"connected_by"
+]), v.metadata({ description: "Connection metadata that describes how an item is connected to a channel.\nThis is only present when the item is returned as part of a channel's contents.\n" }));
+const ChannelOwnerSchema = v.pipe(v.union([EmbeddedUserSchema, EmbeddedGroupSchema]), v.metadata({ description: "Channel owner (User or Group)" }));
+const BlockSourceSchema = v.required(v.partial(v.object({
+	url: v.pipe(v.string(), v.metadata({ description: "Source URL" }), v.examples(["https://example.com/article"])),
+	title: v.pipe(v.union([
+		v.string(),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Source title" }), v.examples(["Original Article Title"])),
+	provider: v.union([
+		BlockProviderSchema,
+		v.null(),
+		v.undefined()
+	])
+})), ["url"]);
+const BlockImageSchema = v.required(v.partial(v.object({
+	alt_text: v.pipe(v.union([
+		v.string(),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Alternative text associated with the image" }), v.examples(["Scanned collage of magazine cutouts"])),
+	blurhash: v.pipe(v.union([
+		v.string(),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "BlurHash representation of the image for progressive loading" }), v.examples(["LEHV6nWB2yk8pyo0adR*.7kCMdnj"])),
+	width: v.pipe(v.union([
+		v.pipe(v.number(), v.integer()),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Original image width in pixels" }), v.examples([1920])),
+	height: v.pipe(v.union([
+		v.pipe(v.number(), v.integer()),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Original image height in pixels" }), v.examples([1080])),
+	aspect_ratio: v.pipe(v.union([
+		v.number(),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Image aspect ratio (width / height)" }), v.examples([1.7778])),
+	content_type: v.pipe(v.string(), v.metadata({ description: "Image content type" }), v.examples(["image/jpeg"])),
+	filename: v.pipe(v.string(), v.metadata({ description: "Image filename" }), v.examples(["image.jpg"])),
+	file_size: v.pipe(v.union([
+		v.pipe(v.number(), v.integer()),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "File size in bytes" }), v.examples([1024e3])),
+	updated_at: v.pipe(v.string(), v.metadata({ description: "When the image was last updated" }), v.examples(["2023-01-15T14:45:00Z"])),
+	small: v.intersect([ImageVersionSchema, v.pipe(v.any(), v.metadata({ description: "Small image version (thumb)" }))]),
+	medium: v.intersect([ImageVersionSchema, v.pipe(v.any(), v.metadata({ description: "Medium image version (display)" }))]),
+	large: v.intersect([ImageVersionSchema, v.pipe(v.any(), v.metadata({ description: "Large image version" }))]),
+	square: v.intersect([ImageVersionSchema, v.pipe(v.any(), v.metadata({ description: "Square cropped image version" }))])
+})), [
+	"small",
+	"medium",
+	"large",
+	"square"
+]);
+const PaginatedResponseWithCountBaseSchema = v.pipe(v.required(v.partial(v.object({ meta: PaginationMetaWithCountSchema })), ["meta"]), v.metadata({ description: "Base schema for paginated responses with total count (use allOf to extend with specific data type)" }));
+const PaginationMetaSchema = v.pipe(v.union([PaginationMetaWithCountSchema, PaginationMetaWithoutCountSchema]), v.metadata({ description: "Pagination metadata union matching pagination behavior with and without total counts" }));
+const UserSchema = v.pipe(v.intersect([EmbeddedUserSchema, v.required(v.partial(v.object({
+	created_at: v.pipe(v.string(), v.metadata({ description: "When the user was created" }), v.examples(["2023-01-15T10:30:00Z"])),
+	updated_at: v.pipe(v.string(), v.metadata({ description: "When the user was last updated" }), v.examples(["2023-06-20T14:45:00Z"])),
+	bio: v.pipe(v.union([
+		MarkdownContentSchema,
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "User biography with markdown, HTML, and plain text renderings" })),
+	counts: UserCountsSchema,
+	_links: v.intersect([LinksSchema, v.pipe(v.any(), v.metadata({ description: "HATEOAS links for navigation" }))])
+})), [
+	"created_at",
+	"updated_at",
+	"counts",
+	"_links"
+])]), v.metadata({ description: "Full user representation" }));
+const GroupSchema = v.pipe(v.intersect([EmbeddedGroupSchema, v.required(v.partial(v.object({
+	bio: v.pipe(v.union([
+		MarkdownContentSchema,
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Group biography with markdown, HTML, and plain text renderings" })),
+	created_at: v.pipe(v.string(), v.metadata({ description: "When the group was created" }), v.examples(["2023-01-15T10:30:00Z"])),
+	updated_at: v.pipe(v.string(), v.metadata({ description: "When the group was last updated" }), v.examples(["2023-06-20T14:45:00Z"])),
+	user: v.intersect([EmbeddedUserSchema, v.pipe(v.any(), v.metadata({ description: "User who owns/created the group" }))]),
+	counts: GroupCountsSchema,
+	_links: v.intersect([LinksSchema, v.pipe(v.any(), v.metadata({ description: "HATEOAS links for navigation" }))])
+})), [
+	"created_at",
+	"updated_at",
+	"user",
+	"counts",
+	"_links"
+])]), v.metadata({ description: "Full group representation" }));
+const CommentSchema = v.pipe(v.required(v.partial(v.object({
+	id: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Unique identifier for the comment" }), v.examples([12345])),
+	type: v.pipe(v.picklist(["Comment"]), v.metadata({ description: "Comment type" }), v.examples(["Comment"])),
+	body: v.pipe(v.union([
+		MarkdownContentSchema,
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Comment body with markdown, HTML, and plain text renderings" })),
+	created_at: v.pipe(v.string(), v.metadata({ description: "When the comment was created" }), v.examples(["2023-01-15T10:30:00Z"])),
+	updated_at: v.pipe(v.string(), v.metadata({ description: "When the comment was last updated" }), v.examples(["2023-01-15T14:45:00Z"])),
+	user: EmbeddedUserSchema,
+	_links: v.intersect([LinksSchema, v.pipe(v.any(), v.metadata({ description: "HATEOAS links for navigation" }))])
+})), [
+	"id",
+	"type",
+	"created_at",
+	"updated_at",
+	"user",
+	"_links"
+]), v.metadata({ description: "A comment on a block" }));
+const ChannelSchema = v.required(v.partial(v.object({
+	id: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Unique identifier for the channel" }), v.examples([12345])),
+	type: v.pipe(v.picklist(["Channel"]), v.metadata({ description: "Channel type" }), v.examples(["Channel"])),
+	slug: v.pipe(v.string(), v.metadata({ description: "Channel URL slug" }), v.examples(["my-collection-abc123"])),
+	title: v.pipe(v.string(), v.metadata({ description: "Channel title" }), v.examples(["My Collection"])),
+	description: v.pipe(v.union([
+		MarkdownContentSchema,
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Channel description with multiple renderings" })),
+	state: v.pipe(v.picklist(["available", "deleted"]), v.metadata({ description: "Lifecycle state of the channel:\n- `available`: Channel is active and accessible\n- `deleted`: Channel has been soft-deleted\n" }), v.examples(["available"])),
+	visibility: v.pipe(v.picklist([
+		"public",
+		"private",
+		"closed"
+	]), v.metadata({ description: "Visibility level of the channel:\n- `public`: Anyone can view and connect to the channel\n- `private`: Only the owner and collaborators can view\n- `closed`: Anyone can view, but only collaborators can add content\n" }), v.examples(["public"])),
+	created_at: v.pipe(v.string(), v.metadata({ description: "When the channel was created" }), v.examples(["2023-01-15T10:30:00Z"])),
+	updated_at: v.pipe(v.string(), v.metadata({ description: "When the channel was last updated" }), v.examples(["2023-01-15T14:45:00Z"])),
+	owner: ChannelOwnerSchema,
+	counts: ChannelCountsSchema,
+	_links: v.intersect([LinksSchema, v.pipe(v.any(), v.metadata({ description: "HATEOAS links for navigation" }))]),
+	connection: v.pipe(v.union([
+		ConnectionContextSchema,
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Connection context (only present when channel is returned as part of another channel's contents).\nContains position, pinned status, and information about who connected the channel.\n" }))
+})), [
+	"id",
+	"type",
+	"slug",
+	"title",
+	"state",
+	"visibility",
+	"created_at",
+	"updated_at",
+	"owner",
+	"counts",
+	"_links"
+]);
+const BaseBlockPropertiesSchema = v.pipe(v.required(v.partial(v.object({
+	id: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Unique identifier for the block" }), v.examples([12345])),
+	base_type: v.pipe(v.picklist(["Block"]), v.metadata({ description: "Base type of the block (always \"Block\")" }), v.examples(["Block"])),
+	title: v.pipe(v.union([
+		v.string(),
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Block title" }), v.examples(["Interesting Article"])),
+	description: v.pipe(v.union([
+		MarkdownContentSchema,
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Block description with multiple renderings" })),
+	state: v.pipe(v.picklist([
+		"available",
+		"pending",
+		"failed",
+		"processing"
+	]), v.metadata({ description: "Processing state of the block:\n- `available`: Block is ready and fully processed\n- `pending`: Block is queued for processing\n- `processing`: Block is currently being processed (e.g., image thumbnails, metadata extraction)\n- `failed`: Block processing failed (may still be viewable but incomplete)\n" }), v.examples(["available"])),
+	visibility: v.pipe(v.picklist([
+		"public",
+		"private",
+		"orphan"
+	]), v.metadata({ description: "Visibility level of the block:\n- `public`: Visible to everyone\n- `private`: Only visible to the owner\n- `orphan`: Block exists but is not connected to any channel\n" }), v.examples(["public"])),
+	comment_count: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Number of comments on the block" }), v.examples([5])),
+	created_at: v.pipe(v.string(), v.metadata({ description: "When the block was created" }), v.examples(["2023-01-15T10:30:00Z"])),
+	updated_at: v.pipe(v.string(), v.metadata({ description: "When the block was last updated" }), v.examples(["2023-01-15T14:45:00Z"])),
+	user: EmbeddedUserSchema,
+	source: v.pipe(v.union([
+		BlockSourceSchema,
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Source URL and metadata (if block was created from a URL)" })),
+	_links: v.intersect([LinksSchema, v.pipe(v.any(), v.metadata({ description: "HATEOAS links for navigation" }))]),
+	connection: v.pipe(v.union([
+		ConnectionContextSchema,
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Connection context (only present when block is returned as part of channel contents).\nContains position, pinned status, and information about who connected the block.\n" }))
+})), [
+	"id",
+	"base_type",
+	"state",
+	"visibility",
+	"comment_count",
+	"created_at",
+	"updated_at",
+	"user",
+	"_links"
+]), v.metadata({ description: "Common properties shared by all block types" }));
+const PaginatedResponseBaseSchema = v.pipe(v.required(v.partial(v.object({ meta: PaginationMetaSchema })), ["meta"]), v.metadata({ description: "Base schema for all paginated responses (use allOf to extend with specific data type)" }));
+const UserListSchema = v.pipe(v.required(v.object({ data: v.pipe(v.array(UserSchema), v.metadata({ description: "Array of users" })) }), ["data"]), v.metadata({ description: "Data payload containing an array of users" }));
+const CommentListSchema = v.pipe(v.required(v.object({ data: v.pipe(v.array(CommentSchema), v.metadata({ description: "Array of comments" })) }), ["data"]), v.metadata({ description: "Data payload containing an array of comments" }));
+const ChannelListSchema = v.pipe(v.required(v.object({ data: v.pipe(v.array(ChannelSchema), v.metadata({ description: "Array of channels" })) }), ["data"]), v.metadata({ description: "Data payload containing an array of channels" }));
+const FollowableListSchema = v.pipe(v.required(v.object({ data: v.pipe(v.array(v.union([
+	UserSchema,
+	ChannelSchema,
+	GroupSchema
+])), v.metadata({ description: "Array of users, channels, and/or groups" })) }), ["data"]), v.metadata({ description: "Data payload containing followable items (users, channels, and groups)" }));
+const TextBlockSchema = v.pipe(v.intersect([BaseBlockPropertiesSchema, v.required(v.object({
+	type: v.pipe(v.picklist(["Text"]), v.metadata({ description: "Block type (always \"Text\" for TextBlock)" })),
+	content: MarkdownContentSchema
+}), ["type", "content"])]), v.metadata({ description: "A text block containing markdown content" }));
+const ImageBlockSchema = v.pipe(v.intersect([BaseBlockPropertiesSchema, v.required(v.object({
+	type: v.pipe(v.picklist(["Image"]), v.metadata({ description: "Block type (always \"Image\" for ImageBlock)" })),
+	image: BlockImageSchema
+}), ["type", "image"])]), v.metadata({ description: "An image block containing an uploaded or scraped image" }));
+const LinkBlockSchema = v.pipe(v.intersect([BaseBlockPropertiesSchema, v.required(v.partial(v.object({
+	type: v.pipe(v.picklist(["Link"]), v.metadata({ description: "Block type (always \"Link\" for LinkBlock)" })),
+	image: v.pipe(v.union([
+		BlockImageSchema,
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Preview image (if available)" })),
+	content: v.pipe(v.union([
+		MarkdownContentSchema,
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Extracted text content from the link" }))
+})), ["type"])]), v.metadata({ description: "A link block representing a URL with optional preview" }));
+const AttachmentBlockSchema = v.pipe(v.intersect([BaseBlockPropertiesSchema, v.required(v.partial(v.object({
+	type: v.pipe(v.picklist(["Attachment"]), v.metadata({ description: "Block type (always \"Attachment\" for AttachmentBlock)" })),
+	attachment: BlockAttachmentSchema,
+	image: v.pipe(v.union([
+		BlockImageSchema,
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Preview image (for PDFs and other previewable files)" }))
+})), ["type", "attachment"])]), v.metadata({ description: "An attachment block containing an uploaded file" }));
+const EmbedBlockSchema = v.pipe(v.intersect([BaseBlockPropertiesSchema, v.required(v.partial(v.object({
+	type: v.pipe(v.picklist(["Embed"]), v.metadata({ description: "Block type (always \"Embed\" for EmbedBlock)" })),
+	embed: BlockEmbedSchema,
+	image: v.pipe(v.union([
+		BlockImageSchema,
+		v.null(),
+		v.undefined()
+	]), v.metadata({ description: "Thumbnail image (if available)" }))
+})), ["type", "embed"])]), v.metadata({ description: "An embed block containing embedded media (video, audio, etc.)" }));
+const UserListResponseSchema = v.pipe(v.intersect([UserListSchema, PaginatedResponseWithCountBaseSchema]), v.metadata({ description: "Paginated list of users with total count" }));
+const CommentListResponseSchema = v.pipe(v.intersect([CommentListSchema, PaginatedResponseWithCountBaseSchema]), v.metadata({ description: "Paginated list of comments with total count" }));
+const ChannelListResponseSchema = v.pipe(v.intersect([ChannelListSchema, PaginatedResponseWithCountBaseSchema]), v.metadata({ description: "Paginated list of channels with total count" }));
+const FollowableListResponseSchema = v.pipe(v.intersect([FollowableListSchema, PaginatedResponseWithCountBaseSchema]), v.metadata({ description: "Paginated list of followable items (users, channels, and groups) with total count" }));
+const BlockSchema = v.pipe(v.union([
+	TextBlockSchema,
+	ImageBlockSchema,
+	LinkBlockSchema,
+	AttachmentBlockSchema,
+	EmbedBlockSchema
+]), v.metadata({ description: "A block is a piece of content on Are.na. Blocks come in different types,\neach with its own set of fields. Use the `type` field to determine which\nfields are available.\n" }));
+const ConnectableListSchema = v.pipe(v.required(v.object({ data: v.pipe(v.array(v.union([
+	TextBlockSchema,
+	ImageBlockSchema,
+	LinkBlockSchema,
+	AttachmentBlockSchema,
+	EmbedBlockSchema,
+	ChannelSchema
+])), v.metadata({ description: "Array of blocks and channels" })) }), ["data"]), v.metadata({ description: "Data payload containing mixed content that can be connected to channels (blocks and channels)" }));
+const EverythingListSchema = v.pipe(v.required(v.object({ data: v.pipe(v.array(v.union([
+	TextBlockSchema,
+	ImageBlockSchema,
+	LinkBlockSchema,
+	AttachmentBlockSchema,
+	EmbedBlockSchema,
+	ChannelSchema,
+	UserSchema,
+	GroupSchema
+])), v.metadata({ description: "Array of results (blocks, channels, users, or groups)" })) }), ["data"]), v.metadata({ description: "Data payload containing all content types" }));
+const ConnectableListResponseSchema = v.pipe(v.intersect([ConnectableListSchema, PaginatedResponseBaseSchema]), v.metadata({ description: "Paginated list of connectable content (blocks and channels)" }));
+const EverythingListResponseSchema = v.pipe(v.intersect([EverythingListSchema, PaginatedResponseWithCountBaseSchema]), v.metadata({ description: "Paginated list of all content types with total count" }));
+
+//#endregion
+//#region src/openapi/components/responses.ts
+const UnauthorizedResponse = { "application/json": ErrorSchema };
+const NotFoundResponse = { "application/json": ErrorSchema };
+const ValidationErrorResponse = { "application/json": ErrorSchema };
+const ForbiddenResponse = { "application/json": ErrorSchema };
+const RateLimitResponse = { "application/json": RateLimitErrorSchema };
+
+//#endregion
+//#region src/openapi/components/parameters.ts
+const PageParamSchema = v.pipe(v.pipe(v.number(), v.integer()), v.examples([1]));
+const PerParamSchema = v.pipe(v.pipe(v.number(), v.integer()), v.examples([24]));
+const IdParamSchema = v.pipe(v.number(), v.integer());
+const SlugOrIdParamSchema = v.string();
+const ConnectionSortParamSchema = ConnectionSortSchema;
+const ContentSortParamSchema = ContentSortSchema;
+const ChannelContentSortParamSchema = ChannelContentSortSchema;
+const ContentTypeFilterParamSchema = ContentTypeFilterSchema;
+
+//#endregion
+//#region src/openapi/paths.ts
+var paths_exports = /* @__PURE__ */ __exportAll({
+	Authentication: () => Authentication,
+	Blocks: () => Blocks,
+	Channels: () => Channels,
+	Groups: () => Groups,
+	Search: () => Search,
+	System: () => System,
+	Users: () => Users
+});
+const Authentication = { createOAuthToken: {
+	method: "post",
+	path: "/v3/oauth/token",
+	parameters: {},
+	body: {
+		required: true,
+		content: { "application/x-www-form-urlencoded": v.required(v.partial(v.object({
+			grant_type: v.pipe(v.picklist(["authorization_code", "client_credentials"]), v.metadata({ description: "The OAuth 2.0 grant type" })),
+			client_id: v.pipe(v.string(), v.metadata({ description: "Your application's client ID (required for all grant types)" })),
+			client_secret: v.pipe(v.string(), v.metadata({ description: "Your application's client secret (required for confidential clients, omit for PKCE)" })),
+			code: v.pipe(v.string(), v.metadata({ description: "Authorization code (required for authorization_code grant)" })),
+			redirect_uri: v.pipe(v.string(), v.metadata({ description: "Redirect URI used in authorization request (required for authorization_code grant)" })),
+			code_verifier: v.pipe(v.string(), v.metadata({ description: "PKCE code verifier (required when authorization used code_challenge).\nMust be 43-128 characters from [A-Z], [a-z], [0-9], \"-\", \".\", \"_\", \"~\".\n" }))
+		})), ["grant_type"]) }
+	},
+	responses: {
+		"200": { "application/json": v.pipe(v.required(v.object({
+			access_token: v.pipe(v.string(), v.metadata({ description: "The access token to use for API requests" })),
+			token_type: v.pipe(v.picklist(["Bearer"]), v.metadata({ description: "Token type (always \"Bearer\")" })),
+			scope: v.pipe(v.string(), v.metadata({ description: "Granted scopes (space-separated)" }), v.examples(["write"])),
+			created_at: v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Unix timestamp when the token was created" }))
+		}), [
+			"access_token",
+			"token_type",
+			"scope",
+			"created_at"
+		]), v.metadata({ description: "Access token granted" })) },
+		"400": { "application/json": v.pipe(v.object({
+			error: v.picklist([
+				"invalid_request",
+				"invalid_client",
+				"invalid_grant",
+				"unauthorized_client",
+				"unsupported_grant_type"
+			]),
+			error_description: v.string()
+		}), v.metadata({ description: "Invalid request" })) },
+		"401": { "application/json": v.pipe(v.object({
+			error: v.pipe(v.string(), v.examples(["invalid_client"])),
+			error_description: v.pipe(v.string(), v.examples(["Client authentication failed due to unknown client or invalid credentials."]))
+		}), v.metadata({ description: "Invalid client credentials" })) }
+	}
+} };
+const System = {
+	getOpenapiSpec: {
+		method: "get",
+		path: "/v3/openapi",
+		parameters: {},
+		responses: {
+			"200": { "application/yaml": v.pipe(v.string(), v.metadata({ description: "OpenAPI specification in YAML format" })) },
+			"404": NotFoundResponse
+		}
+	},
+	getOpenapiSpecJson: {
+		method: "get",
+		path: "/v3/openapi.json",
+		parameters: {},
+		responses: {
+			"200": { "application/json": v.pipe(v.record(v.string(), v.union([])), v.metadata({ description: "OpenAPI specification in JSON format" })) },
+			"404": NotFoundResponse
+		}
+	},
+	getPing: {
+		method: "get",
+		path: "/v3/ping",
+		parameters: {},
+		responses: {
+			"200": { "application/json": PingResponseSchema },
+			"429": RateLimitResponse
+		}
+	}
+};
+const Blocks = { id: {
+	$parameters: { id: IdParamSchema },
+	getBlock: {
+		method: "get",
+		path: "/v3/blocks/{id}",
+		parameters: { path: { id: IdParamSchema } },
+		responses: {
+			"200": { "application/json": BlockSchema },
+			"401": UnauthorizedResponse,
+			"403": ForbiddenResponse,
+			"404": NotFoundResponse,
+			"429": RateLimitResponse
+		}
+	},
+	getBlockConnections: {
+		method: "get",
+		path: "/v3/blocks/{id}/connections",
+		parameters: {
+			path: { id: IdParamSchema },
+			query: {
+				page: v.nullish(PageParamSchema),
+				per: v.nullish(PerParamSchema),
+				sort: v.nullish(ConnectionSortParamSchema),
+				filter: v.nullish(v.pipe(v.picklist([
+					"ALL",
+					"OWN",
+					"EXCLUDE_OWN"
+				]), v.metadata({ description: "Filter connections by ownership:\n- `ALL`: All accessible connections (default)\n- `OWN`: Only connections created by the current user\n- `EXCLUDE_OWN`: All connections except those created by the current user\n" }), v.examples(["ALL"])))
+			}
+		},
+		responses: {
+			"200": { "application/json": ChannelListResponseSchema },
+			"401": UnauthorizedResponse,
+			"403": ForbiddenResponse,
+			"404": NotFoundResponse,
+			"429": RateLimitResponse
+		}
+	},
+	getBlockComments: {
+		method: "get",
+		path: "/v3/blocks/{id}/comments",
+		parameters: {
+			path: { id: IdParamSchema },
+			query: {
+				page: v.nullish(PageParamSchema),
+				per: v.nullish(PerParamSchema),
+				sort: v.nullish(ConnectionSortParamSchema)
+			}
+		},
+		responses: {
+			"200": { "application/json": CommentListResponseSchema },
+			"401": UnauthorizedResponse,
+			"403": ForbiddenResponse,
+			"404": NotFoundResponse,
+			"429": RateLimitResponse
+		}
+	}
+} };
+const Channels = { id: {
+	$parameters: { id: SlugOrIdParamSchema },
+	getChannel: {
+		method: "get",
+		path: "/v3/channels/{id}",
+		parameters: { path: { id: SlugOrIdParamSchema } },
+		responses: {
+			"200": { "application/json": ChannelSchema },
+			"401": UnauthorizedResponse,
+			"403": ForbiddenResponse,
+			"404": NotFoundResponse,
+			"429": RateLimitResponse
+		}
+	},
+	getChannelContents: {
+		method: "get",
+		path: "/v3/channels/{id}/contents",
+		parameters: {
+			path: { id: SlugOrIdParamSchema },
+			query: {
+				page: v.nullish(PageParamSchema),
+				per: v.nullish(PerParamSchema),
+				sort: v.nullish(ChannelContentSortParamSchema),
+				user_id: v.nullish(v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Filter by user who added the content" }), v.examples([12345])))
+			}
+		},
+		responses: {
+			"200": { "application/json": ConnectableListResponseSchema },
+			"401": UnauthorizedResponse,
+			"403": ForbiddenResponse,
+			"404": NotFoundResponse,
+			"429": RateLimitResponse
+		}
+	},
+	getChannelConnections: {
+		method: "get",
+		path: "/v3/channels/{id}/connections",
+		parameters: {
+			path: { id: SlugOrIdParamSchema },
+			query: {
+				page: v.nullish(PageParamSchema),
+				per: v.nullish(PerParamSchema),
+				sort: v.nullish(ConnectionSortParamSchema)
+			}
+		},
+		responses: {
+			"200": { "application/json": ChannelListResponseSchema },
+			"401": UnauthorizedResponse,
+			"403": ForbiddenResponse,
+			"404": NotFoundResponse,
+			"429": RateLimitResponse
+		}
+	},
+	getChannelFollowers: {
+		method: "get",
+		path: "/v3/channels/{id}/followers",
+		parameters: {
+			path: { id: SlugOrIdParamSchema },
+			query: {
+				page: v.nullish(PageParamSchema),
+				per: v.nullish(PerParamSchema),
+				sort: v.nullish(ConnectionSortParamSchema)
+			}
+		},
+		responses: {
+			"200": { "application/json": UserListResponseSchema },
+			"401": UnauthorizedResponse,
+			"403": ForbiddenResponse,
+			"404": NotFoundResponse,
+			"429": RateLimitResponse
+		}
+	}
+} };
+const Users = {
+	getCurrentUser: {
+		method: "get",
+		path: "/v3/me",
+		parameters: {},
+		responses: {
+			"200": { "application/json": UserSchema },
+			"401": UnauthorizedResponse,
+			"429": RateLimitResponse
+		}
+	},
+	id: {
+		$parameters: { id: SlugOrIdParamSchema },
+		getUser: {
+			method: "get",
+			path: "/v3/users/{id}",
+			parameters: { path: { id: SlugOrIdParamSchema } },
+			responses: {
+				"200": { "application/json": UserSchema },
+				"401": UnauthorizedResponse,
+				"403": ForbiddenResponse,
+				"404": NotFoundResponse,
+				"429": RateLimitResponse
+			}
+		},
+		getUserContents: {
+			method: "get",
+			path: "/v3/users/{id}/contents",
+			parameters: {
+				path: { id: SlugOrIdParamSchema },
+				query: {
+					page: v.nullish(PageParamSchema),
+					per: v.nullish(PerParamSchema),
+					sort: v.nullish(ContentSortParamSchema),
+					type: v.nullish(ContentTypeFilterParamSchema)
+				}
+			},
+			responses: {
+				"200": { "application/json": ConnectableListResponseSchema },
+				"401": UnauthorizedResponse,
+				"403": ForbiddenResponse,
+				"404": NotFoundResponse,
+				"429": RateLimitResponse
+			}
+		},
+		getUserFollowers: {
+			method: "get",
+			path: "/v3/users/{id}/followers",
+			parameters: {
+				path: { id: SlugOrIdParamSchema },
+				query: {
+					page: v.nullish(PageParamSchema),
+					per: v.nullish(PerParamSchema),
+					sort: v.nullish(ConnectionSortParamSchema)
+				}
+			},
+			responses: {
+				"200": { "application/json": UserListResponseSchema },
+				"401": UnauthorizedResponse,
+				"403": ForbiddenResponse,
+				"404": NotFoundResponse,
+				"429": RateLimitResponse
+			}
+		},
+		getUserFollowing: {
+			method: "get",
+			path: "/v3/users/{id}/following",
+			parameters: {
+				path: { id: SlugOrIdParamSchema },
+				query: {
+					page: v.nullish(PageParamSchema),
+					per: v.nullish(PerParamSchema),
+					sort: v.nullish(ConnectionSortParamSchema),
+					type: v.nullish(v.pipe(v.picklist([
+						"User",
+						"Channel",
+						"Group"
+					]), v.metadata({ description: "Filter by followable type" }), v.examples(["Channel"])))
+				}
+			},
+			responses: {
+				"200": { "application/json": FollowableListResponseSchema },
+				"401": UnauthorizedResponse,
+				"403": ForbiddenResponse,
+				"404": NotFoundResponse,
+				"429": RateLimitResponse
+			}
+		}
+	}
+};
+const Groups = { id: {
+	$parameters: { id: SlugOrIdParamSchema },
+	getGroup: {
+		method: "get",
+		path: "/v3/groups/{id}",
+		parameters: { path: { id: SlugOrIdParamSchema } },
+		responses: {
+			"200": { "application/json": GroupSchema },
+			"401": UnauthorizedResponse,
+			"403": ForbiddenResponse,
+			"404": NotFoundResponse,
+			"429": RateLimitResponse
+		}
+	},
+	getGroupContents: {
+		method: "get",
+		path: "/v3/groups/{id}/contents",
+		parameters: {
+			path: { id: SlugOrIdParamSchema },
+			query: {
+				page: v.nullish(PageParamSchema),
+				per: v.nullish(PerParamSchema),
+				sort: v.nullish(ContentSortParamSchema),
+				type: v.nullish(ContentTypeFilterParamSchema)
+			}
+		},
+		responses: {
+			"200": { "application/json": ConnectableListResponseSchema },
+			"401": UnauthorizedResponse,
+			"403": ForbiddenResponse,
+			"404": NotFoundResponse,
+			"429": RateLimitResponse
+		}
+	},
+	getGroupFollowers: {
+		method: "get",
+		path: "/v3/groups/{id}/followers",
+		parameters: {
+			path: { id: SlugOrIdParamSchema },
+			query: {
+				page: v.nullish(PageParamSchema),
+				per: v.nullish(PerParamSchema),
+				sort: v.nullish(ConnectionSortParamSchema)
+			}
+		},
+		responses: {
+			"200": { "application/json": UserListResponseSchema },
+			"401": UnauthorizedResponse,
+			"403": ForbiddenResponse,
+			"404": NotFoundResponse,
+			"429": RateLimitResponse
+		}
+	}
+} };
+const Search = { search: {
+	method: "get",
+	path: "/v3/search",
+	parameters: { query: {
+		q: v.nullish(v.pipe(v.string(), v.metadata({ description: "Search query. Use `*` to match everything (useful with filters).\n" }), v.examples(["design"]))),
+		type: v.nullish(v.pipe(v.array(SearchTypeFilterSchema), v.metadata({ description: "Content types to search (comma-separated).\nBlock subtypes: Text, Image, Link, Attachment, Embed.\nOther: Channel, User, Group, Block (all block types).\n" }), v.examples([["Image", "Link"]]))),
+		scope: v.nullish(v.pipe(v.string(), v.metadata({ description: "Where to search:\n- `all` - Everything (default)\n- `my` - Current user's content\n- `following` - Content from followed users/channels\n- `user:ID` - Specific user's content\n- `group:ID` - Specific group's content\n- `channel:ID` - Specific channel's content\n" }), v.examples(["channel:12345"]))),
+		in: v.nullish(v.pipe(v.array(v.picklist([
+			"name",
+			"description",
+			"content",
+			"domain",
+			"url"
+		])), v.metadata({ description: "Fields to search within (comma-separated).\nOptions: name, description, content, domain, url.\nDefaults to all fields.\n" }), v.examples([["name", "description"]]))),
+		ext: v.nullish(v.pipe(v.array(FileExtensionSchema), v.metadata({ description: "Filter by file extensions (comma-separated)" }), v.examples([["pdf", "jpg"]]))),
+		sort: v.nullish(v.pipe(v.picklist([
+			"score_desc",
+			"created_at_desc",
+			"created_at_asc",
+			"updated_at_desc",
+			"updated_at_asc",
+			"name_asc",
+			"name_desc",
+			"connections_count_desc",
+			"random"
+		]), v.metadata({ description: "Sort order. Options:\n- `score_desc` (default) - Relevance\n- `created_at_desc`, `created_at_asc`\n- `updated_at_desc`, `updated_at_asc`\n- `name_asc`, `name_desc`\n- `connections_count_desc`\n- `random` (use with `seed` for reproducibility)\n" }), v.examples(["created_at_desc"]))),
+		after: v.nullish(v.pipe(v.string(), v.metadata({ description: "Only return results updated after this date (ISO 8601)" }), v.examples(["2024-01-01T00:00:00Z"]))),
+		seed: v.nullish(v.pipe(v.pipe(v.number(), v.integer()), v.metadata({ description: "Random seed for reproducible results (use with `sort=random`)" }), v.examples([1234567890]))),
+		page: v.nullish(PageParamSchema),
+		per: v.nullish(PerParamSchema)
+	} },
+	responses: {
+		"200": { "application/json": EverythingListResponseSchema },
+		"400": ValidationErrorResponse,
+		"401": UnauthorizedResponse,
+		"403": { "application/json": ErrorSchema },
+		"429": RateLimitResponse
+	}
+} };
+
+//#endregion
+//#region src/util.ts
+function findKeyWithSingleOccurrence(obj, targetKey) {
+	let foundKey = null;
+	for (const [key, value] of Object.entries(obj)) {
+		if (typeof value !== "object" || value === null) continue;
+		let count = 0;
+		for (const childKey of Object.keys(value)) if (childKey === targetKey) {
+			count++;
+			if (count > 1) break;
+		}
+		if (count === 1) {
+			if (foundKey !== null) return null;
+			foundKey = key;
+		}
+	}
+	return foundKey;
+}
+function removeCommonPrefix(obj, defaultKey) {
+	const keys = Object.keys(obj);
+	if (keys.length === 0) return {};
+	const findCommonPrefix = (strings) => {
+		if (strings.length === 0) return "";
+		if (strings.length === 1) return strings[0];
+		let prefix = "";
+		const first = strings[0];
+		for (let i = 0; i < first.length; i++) {
+			const char = first[i];
+			if (strings.every((s) => s[i] === char)) prefix += char;
+			else break;
+		}
+		return prefix;
+	};
+	const commonPrefix = findCommonPrefix(keys);
+	const result = {};
+	for (const key of keys) {
+		let newKey = key.slice(commonPrefix.length);
+		if (newKey === "") newKey = defaultKey !== void 0 ? defaultKey : key;
+		else newKey = newKey.charAt(0).toLowerCase() + newKey.slice(1);
+		result[newKey] = obj[key];
+	}
+	return result;
+}
+
+//#endregion
+//#region node_modules/.bun/form-urlencoded@6.1.6/node_modules/form-urlencoded/form-urlencoded.mjs
+var form_urlencoded_default = (data, opts = {}) => {
+	const { sorted, ignorenull, ignoreEmptyArray, useDot, skipIndex, skipBracket, whitespace = "+" } = opts;
+	const encode = (value) => String(value).replace(/[^ !'()~*]/gu, encodeURIComponent).replace(/ /g, whitespace).replace(/[!'()~*]/g, (ch) => `%${ch.charCodeAt().toString(16).slice(-2).toUpperCase()}`);
+	const keys = (obj, keyarr = Object.keys(obj)) => sorted ? keyarr.sort() : keyarr;
+	const filterjoin = (arr) => arr.filter((e) => e).join("&");
+	const objnest = (name, obj) => filterjoin(keys(obj).map((key) => useDot ? nest(`${name}.${key}`, obj[key]) : nest(`${name}[${key}]`, obj[key])));
+	const arrnest = (name, arr, brackets = skipBracket ? "" : "[]") => arr.length ? filterjoin(arr.map((elem, index) => skipIndex ? nest(name + brackets, elem) : nest(name + "[" + index + "]", elem))) : ignoreEmptyArray ? null : encode(name + brackets);
+	const setnest = (name, set) => filterjoin(Array.from(set).map((elem) => nest(name, elem)));
+	const nest = (name, value, type = typeof value, f = null) => {
+		if (value === f) f = ignorenull ? f : encode(name) + "=" + f;
+		else if (/string|number|boolean/.test(type)) f = encode(name) + "=" + encode(value);
+		else if (Array.isArray(value)) f = arrnest(name, value);
+		else if (value instanceof Set) f = setnest(name, value);
+		else if (type === "object") f = objnest(name, value);
+		return f;
+	};
+	return data && filterjoin(keys(data).map((key) => nest(key, data[key])));
+};
+
+//#endregion
+//#region src/api/index.ts
+const getMethodArgKind = (method) => "query" in method.parameters ? "query" : method.body != null && "content" in method.body ? "body" : null;
+const createApi = ({ accessToken, baseUrl, ...init } = { baseUrl: "https://api.are.na" }) => {
+	const createFetch = (baseUrl, baseInit) => (url, init = {}, modifyUrl = (u) => u) => global.fetch(modifyUrl(new URL(url.toString(), baseUrl)), Object.assign({}, baseInit, init));
+	if (accessToken) {
+		init.headers ??= {};
+		init.headers = new Headers(init.headers);
+		init.headers.set("Authorization", `Bearer ${accessToken}`);
+	}
+	const fetch = createFetch(new URL(baseUrl), init);
+	return Object.fromEntries(Object.entries(paths_exports).map(([group, value]) => {
+		const singleKey = findKeyWithSingleOccurrence(value, "$parameters");
+		const makeMethod = (method) => {
+			const argKind = getMethodArgKind(method);
+			const localFetch = (init = {}, modifyUrl = (u) => u) => fetch(method.path, Object.assign({}, { method: method.method }, init ?? {}), modifyUrl ?? ((u) => u));
+			return async (arg) => {
+				const res = await localFetch(argKind === "body" && arg != null ? (() => {
+					const content = method.body?.content;
+					let contentType;
+					let body;
+					for (const media in content) {
+						const schema = content[media];
+						if (schema == null) continue;
+						const maybeBody = v.safeParse(schema, arg);
+						if (maybeBody.success) {
+							contentType = media;
+							body = maybeBody.output;
+						}
+					}
+					if (!contentType) return {};
+					return {
+						headers: { "Content-Type": contentType },
+						body: contentType.endsWith("x-www-form-urlencoded") ? form_urlencoded_default(body) : body
+					};
+				})() : void 0, argKind === "query" && arg != null ? (() => {
+					const nextQuery = Object.fromEntries(Object.entries(arg).map(([key, value]) => [key, method.parameters["query"]?.[key] ? v.parse(method.parameters["query"]?.[key], value) : value]));
+					return (u) => {
+						for (const key in nextQuery) {
+							const value = nextQuery[key];
+							if (value == null) continue;
+							u.searchParams.set(key, value);
+						}
+						return u;
+					};
+				})() : void 0);
+				const statusCodeResponseData = method.responses[res.status] ?? {};
+				const contentTypeResponseData = res.headers.has("content-type") ? statusCodeResponseData?.[res.headers.get("content-type")?.split(";").at(0)] : null;
+				const result = await (Object.keys(statusCodeResponseData).includes("application/json") ? res.json() : res.text());
+				return contentTypeResponseData != null ? v.parse(contentTypeResponseData, result) : result;
+			};
+		};
+		const makeMethods = (value, parameters = {
+			path: {},
+			query: {}
+		}) => {
+			const replacePathPart = Object.fromEntries(Object.entries(parameters.path ?? {}).map(([key, value]) => [`{${key}}`, value]));
+			return Object.fromEntries(Object.entries(Object.keys(value).length > 1 ? removeCommonPrefix(value, "self") : value).map(([key, value]) => [key, makeMethod(Object.assign({}, value, { path: value.path.split("/").map((p) => replacePathPart[p] ?? p).join("/") }))]));
+		};
+		return [group.toLowerCase(), singleKey ? Object.assign((param) => {
+			const { $parameters, ...methods } = paths_exports[group][singleKey];
+			return makeMethods(methods, { path: { [`${Object.keys($parameters).at(0)}`]: `${param}` } });
+		}, makeMethods(Object.fromEntries(Object.entries(value).filter(([key]) => key !== singleKey)))) : (() => {
+			const keys = Object.keys(value);
+			return keys.length === 1 && keys.map((k) => k.toLowerCase()).includes(group.toLowerCase());
+		})() ? makeMethod(value[group.toLowerCase()]) : makeMethods(value)];
+	}));
+};
+
+//#endregion
+export { createApi as createArena };