@takuhon/core 0.11.0 → 0.13.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 var $schema = "https://json-schema.org/draft/2020-12/schema";
-var $id = "https://takuhon.example/schemas/0.4.0/takuhon.schema.json";
+var $id = "https://takuhon.example/schemas/0.5.0/takuhon.schema.json";
 var title = "Takuhon Profile";
 var description = "Portable profile data format consumed by @takuhon/core. The canonical contract for profile content authored as takuhon.json.";
 var type = "object";
@@ -542,6 +542,74 @@ var $defs = {
 				type: "boolean",
 				"default": false,
 				description: "Opt-in flag for first-party analytics. Default is false to keep takuhon privacy-respecting by default."
+			},
+			activity: {
+				$ref: "#/$defs/ActivitySettings"
+			}
+		}
+	},
+	ActivitySettings: {
+		type: "object",
+		additionalProperties: false,
+		description: "Opt-in developer-activity dashboard configuration (GitHub / WakaTime). Only the owner-curated settings live here; secrets are provisioned out of band and the synced metrics are stored in a separate document, never in takuhon.json.",
+		properties: {
+			enabled: {
+				type: "boolean",
+				"default": false,
+				description: "Master switch. When false (the default), the activity section is not rendered even if a snapshot exists."
+			},
+			github: {
+				type: "object",
+				additionalProperties: false,
+				required: [
+					"username"
+				],
+				properties: {
+					username: {
+						type: "string",
+						minLength: 1,
+						maxLength: 39,
+						description: "GitHub login whose public activity is summarized."
+					},
+					showLanguages: {
+						type: "boolean",
+						"default": true
+					},
+					showContributions: {
+						type: "boolean",
+						"default": true
+					}
+				}
+			},
+			wakatime: {
+				type: "object",
+				additionalProperties: false,
+				required: [
+					"username"
+				],
+				properties: {
+					username: {
+						type: "string",
+						minLength: 1,
+						maxLength: 255,
+						description: "WakaTime username whose coding-time stats are summarized."
+					},
+					showCodingTime: {
+						type: "boolean",
+						"default": true
+					}
+				}
+			},
+			showRank: {
+				type: "boolean",
+				"default": true,
+				description: "Display the derived activity rank / badge."
+			},
+			refreshHintHours: {
+				type: "integer",
+				minimum: 1,
+				maximum: 168,
+				description: "Advisory refresh cadence in hours. The real cadence is how often the sync step (CLI command or scheduled job) runs."
 			}
 		}
 	},
@@ -1664,6 +1732,70 @@ declare const schema: {
                     default: boolean;
                     description: string;
                 };
+                activity: {
+                    $ref: string;
+                };
+            };
+        };
+        ActivitySettings: {
+            type: string;
+            additionalProperties: boolean;
+            description: string;
+            properties: {
+                enabled: {
+                    type: string;
+                    default: boolean;
+                    description: string;
+                };
+                github: {
+                    type: string;
+                    additionalProperties: boolean;
+                    required: string[];
+                    properties: {
+                        username: {
+                            type: string;
+                            minLength: number;
+                            maxLength: number;
+                            description: string;
+                        };
+                        showLanguages: {
+                            type: string;
+                            default: boolean;
+                        };
+                        showContributions: {
+                            type: string;
+                            default: boolean;
+                        };
+                    };
+                };
+                wakatime: {
+                    type: string;
+                    additionalProperties: boolean;
+                    required: string[];
+                    properties: {
+                        username: {
+                            type: string;
+                            minLength: number;
+                            maxLength: number;
+                            description: string;
+                        };
+                        showCodingTime: {
+                            type: string;
+                            default: boolean;
+                        };
+                    };
+                };
+                showRank: {
+                    type: string;
+                    default: boolean;
+                    description: string;
+                };
+                refreshHintHours: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                    description: string;
+                };
             };
         };
         Meta: {
@@ -2515,6 +2647,32 @@ interface Settings {
     enableApi?: boolean;
     /** Opt-in flag for first-party analytics. Default is false. */
     enableAnalytics?: boolean;
+    /** Opt-in developer-activity dashboard configuration (added in 0.5.0). */
+    activity?: ActivitySettings;
+}
+/**
+ * Owner-curated configuration for the developer-activity dashboard (GitHub /
+ * WakaTime). Secrets (API tokens) are provisioned out of band and never stored
+ * here; the synced metrics live in a separate document, not in `takuhon.json`.
+ */
+interface ActivitySettings {
+    /** Master switch; the section is hidden when false (the default). */
+    enabled?: boolean;
+    github?: {
+        /** GitHub login whose public activity is summarized. */
+        username: string;
+        showLanguages?: boolean;
+        showContributions?: boolean;
+    };
+    wakatime?: {
+        /** WakaTime username whose coding-time stats are summarized. */
+        username: string;
+        showCodingTime?: boolean;
+    };
+    /** Display the derived activity rank / badge. */
+    showRank?: boolean;
+    /** Advisory refresh cadence in hours (the real cadence is the sync schedule). */
+    refreshHintHours?: number;
 }
 interface ContentLicenseAttribution {
     name?: string;
@@ -2862,7 +3020,7 @@ interface LocalizedTakuhon {
  * versions whose JSON Schema this package literally bundles, not the full
  * support window seen by end users.
  */
-declare const SUPPORTED_SCHEMA_VERSIONS: readonly ["0.1.0", "0.2.0", "0.3.0", "0.4.0"];
+declare const SUPPORTED_SCHEMA_VERSIONS: readonly ["0.1.0", "0.2.0", "0.3.0", "0.4.0", "0.5.0"];
 /**
  * A single validation failure.
  *
@@ -3169,9 +3327,9 @@ declare function applyPublicPrivacyFilter<T extends FilterableProfile>(profile:
  *
  * {@link migrateTakuhon} composes a chain of {@link Migration} entries from
  * the registry (`./migrations`) and applies them in order. The registry
- * currently ships the `0.1.0 → 0.2.0`, `0.2.0 → 0.3.0`, and `0.3.0 → 0.4.0`
- * forward migrations; a request whose source has no chain to the target
- * throws {@link MigrationError}.
+ * currently ships the `0.1.0 → 0.2.0`, `0.2.0 → 0.3.0`, `0.3.0 → 0.4.0`, and
+ * `0.4.0 → 0.5.0` forward migrations; a request whose source has no chain to
+ * the target throws {@link MigrationError}.
  *
  * Scope (deliberately narrow, mirroring `export.ts`):
  * - Pure data transform — no I/O, no backup creation, no storage write.
@@ -3240,6 +3398,130 @@ interface Migration<From, To> {
  */
 declare const migrations: readonly Migration<Takuhon, Takuhon>[];
 
+/**
+ * Developer-activity snapshot: types, a runtime type-guard, and the pure,
+ * network-free transforms that turn raw GitHub / WakaTime figures into the
+ * stored, render-ready shape.
+ *
+ * This module is deliberately dependency-free and platform-independent — it
+ * never performs I/O or network access. Fetching the raw figures from GitHub /
+ * WakaTime lives in a separate, runtime-aware package (`@takuhon/activity`);
+ * core only owns the data shape and the deterministic transforms, so every
+ * runtime renders identical output from the same snapshot.
+ *
+ * The {@link ActivitySnapshot} is NOT part of the canonical `takuhon.json`
+ * document. It is machine-written by a sync step (a CLI command or a scheduled
+ * job), persisted in a sibling document via {@link ActivityStorage}, and read
+ * by the renderer. Keeping it out of the canonical, owner-curated identity
+ * document is intentional: externally-sourced, volatile metrics must not enter
+ * the single source of truth a profile owner hand-maintains.
+ */
+/** One language's share of analyzed source, derived from byte counts. */
+interface LanguageBreakdown {
+    /** Language name as reported by the source (e.g. `"TypeScript"`). */
+    name: string;
+    /** Total bytes attributed to this language across analyzed repositories. */
+    bytes: number;
+    /** Share of the analyzed total, 0–100, rounded to one decimal place. */
+    percent: number;
+}
+/** A single day in a contribution calendar. */
+interface ContributionDay {
+    /** ISO-8601 calendar date (`YYYY-MM-DD`). */
+    date: string;
+    /** Contribution count on that day. */
+    count: number;
+}
+/** Contribution activity over a window (e.g. the trailing year). */
+interface ContributionCalendar {
+    /** Total contributions across the window. */
+    total: number;
+    /** Per-day counts, in chronological order. */
+    days: ContributionDay[];
+}
+/** Coding time decomposed into whole hours/minutes/seconds plus the raw total. */
+interface CodingTime {
+    totalSeconds: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+}
+/** Coarse activity tier label, highest (`S`) to lowest (`D`). */
+type RankTierLabel = 'S' | 'A' | 'B' | 'C' | 'D';
+/** A derived activity rank: a tier label plus the 0–100 score it came from. */
+interface RankTier {
+    tier: RankTierLabel;
+    /** Normalized 0–100 activity score the tier was derived from. */
+    score: number;
+}
+/**
+ * A point-in-time snapshot of externally-sourced developer-activity metrics
+ * (GitHub languages / contributions, WakaTime coding time, and a derived rank).
+ *
+ * Every metric field is optional so the snapshot degrades gracefully when a
+ * source is unconfigured or temporarily unavailable: the renderer shows what is
+ * present and omits the rest. Only {@link lastSyncedAt} is required so staleness
+ * is always displayable.
+ */
+interface ActivitySnapshot {
+    /** ISO-8601 timestamp of when this snapshot was produced. */
+    lastSyncedAt: string;
+    languages?: LanguageBreakdown[];
+    contributions?: ContributionCalendar;
+    codingTime?: CodingTime;
+    rank?: RankTier;
+}
+/**
+ * Validate that an unknown value (e.g. one read back from storage) is a
+ * well-formed {@link ActivitySnapshot}. A lightweight runtime guard is
+ * sufficient here — the snapshot is machine-written and self-owned, so it does
+ * not warrant a full JSON Schema validator like `takuhon.json`. A malformed or
+ * truncated snapshot fails the guard and the renderer treats it as absent.
+ */
+declare function isActivitySnapshot(value: unknown): value is ActivitySnapshot;
+/**
+ * Turn per-language byte counts (as GitHub's `repos/.../languages` reports) into
+ * sorted percentage breakdowns. Languages with zero bytes are dropped; the
+ * result is sorted by bytes descending, ties broken by name, so the output is
+ * deterministic. Percentages are rounded to one decimal place and need not sum
+ * to exactly 100. Returns `[]` when there is nothing to attribute.
+ */
+declare function computeLanguagePercentages(bytesByLanguage: Readonly<Record<string, number>>): LanguageBreakdown[];
+/** Decompose a total number of seconds into whole h/m/s (negatives clamp to 0). */
+declare function formatCodingTime(totalSeconds: number): CodingTime;
+/** Inputs to {@link deriveRankTier}; any field may be absent. */
+interface RankInput {
+    /** Contributions in the trailing window (e.g. the past year). */
+    contributions?: number;
+    /** Total coding time, in seconds. */
+    codingSeconds?: number;
+}
+/** Contribution count that saturates the contribution sub-score at 100. */
+declare const RANK_FULL_CONTRIBUTIONS = 2000;
+/** Coding hours that saturate the coding-time sub-score at 100. */
+declare const RANK_FULL_CODING_HOURS = 2000;
+/**
+ * Inclusive lower bounds for each tier on the 0–100 score (anything below `C`
+ * is `D`). These are a deliberately generic, transparent default — not tuned to
+ * any individual — and may be revisited.
+ */
+declare const RANK_TIER_THRESHOLDS: {
+    readonly S: 80;
+    readonly A: 60;
+    readonly B: 40;
+    readonly C: 20;
+};
+/**
+ * Derive a coarse activity {@link RankTier} from the available signals. Each
+ * present signal is mapped to a 0–100 sub-score via linear saturation
+ * ({@link RANK_FULL_CONTRIBUTIONS} / {@link RANK_FULL_CODING_HOURS} reach 100);
+ * the final score is the mean of the present sub-scores, so a profile is not
+ * penalized for leaving a source unconfigured. With no signals the score is 0
+ * (`D`). The function is deterministic — no clock or randomness — so renders are
+ * reproducible.
+ */
+declare function deriveRankTier(input: RankInput): RankTier;
+
 /**
  * Persistence contracts for takuhon profile documents and binary assets.
  *
@@ -3323,8 +3605,14 @@ interface AssetRecord {
 /**
  * Caller hints for {@link TakuhonAssetStorage.putAsset}. Both fields are
  * optional; when omitted, the adapter falls back to the `File` / `Blob`
- * metadata. Adapters are responsible for magic-byte verification, EXIF
- * stripping, and dimension limits — callers must not pre-process.
+ * metadata.
+ *
+ * The caller (`@takuhon/api`'s admin app) verifies the magic bytes, enforces
+ * the size / dimension / frame limits, and strips metadata (EXIF / IPTC / XMP /
+ * color profile) before calling `putAsset`, using the shared `@takuhon/core`
+ * image helpers, so every adapter applies the same checks. An adapter therefore
+ * persists the already-validated, already-stripped bytes verbatim and is
+ * responsible only for storage and key/URL generation.
  */
 interface AssetOptions {
     filename?: string;
@@ -3346,6 +3634,27 @@ interface TakuhonAssetStorage {
     deleteAsset(assetId: string): Promise<void>;
     listAssets(): Promise<AssetRecord[]>;
 }
+/**
+ * Persistence contract for the developer-activity snapshot (see
+ * {@link ActivitySnapshot}). Like {@link TakuhonAssetStorage}, this is a
+ * separate, optional interface so deployments that don't enable the activity
+ * feature can omit it entirely.
+ *
+ * Unlike {@link TakuhonStorage}, there is no optimistic-locking `version`: the
+ * snapshot is machine-written by a sync step (a CLI command or a scheduled job)
+ * with last-writer-wins semantics and is never concurrently hand-edited.
+ */
+interface ActivityStorage {
+    /**
+     * Read the current activity snapshot, or `null` when none has been synced
+     * yet. Returns `null` rather than throwing {@link NotFoundError}: an absent
+     * snapshot is the normal opt-out / pre-sync state, and the renderer omits the
+     * activity section gracefully when it is `null`.
+     */
+    getActivitySnapshot(): Promise<ActivitySnapshot | null>;
+    /** Replace the stored snapshot (last-writer-wins; no precondition). */
+    saveActivitySnapshot(snapshot: ActivitySnapshot): Promise<void>;
+}
 /**
  * Base class for errors thrown by storage adapters. Catch this to handle
  * any storage-layer failure uniformly; check `instanceof` of a subclass
@@ -3378,6 +3687,182 @@ declare class ConflictError extends StorageError {
     });
 }
 
+/**
+ * Self-owned inline SVG rendering of an {@link ActivitySnapshot}.
+ *
+ * The dashboard is drawn from the stored snapshot only — no external badge
+ * image, no network access — so a page embedding it keeps a strict
+ * `img-src 'self'` Content-Security-Policy. The output is a deterministic pure
+ * string: no clock, no randomness, no locale-dependent formatting — the same
+ * snapshot always renders the same markup, so both rendering surfaces (the
+ * static HTML export and the React profile) and their tests stay in lockstep.
+ *
+ * Every snapshot-derived string (language names, dates) is XML-escaped before
+ * it reaches the markup: language names come from an external API and are
+ * treated as untrusted. An empty snapshot (no metric fields) renders to `''`
+ * so callers can omit the section with a truthiness check.
+ */
+
+/**
+ * Render the activity snapshot as a self-contained `<svg>` string, or `''`
+ * when the snapshot carries no metric data (so callers can omit the section).
+ * Sections render independently — whatever the snapshot holds is shown, the
+ * rest is left out — and `lastSyncedAt`'s date is always stamped in the footer
+ * so staleness stays visible.
+ */
+declare function renderActivitySvg(snapshot: ActivitySnapshot): string;
+
+/**
+ * Résumé / CV projection of a profile.
+ *
+ * {@link deriveCv} turns one locale-resolved {@link LocalizedTakuhon} into a
+ * {@link CvDocument}: a header plus the CV-relevant sections in a fixed,
+ * résumé-conventional order. It is a pure, deterministic selection-and-projection
+ * — no clock, no randomness, no I/O — so the static export ({@link
+ * import('@takuhon/cli')}) and a React `CvView` render identical output from the
+ * same input.
+ *
+ * A CV is a curated *subset* of the profile: the web-page-specific sections
+ * (links, recommendations, the activity dashboard, test scores) are omitted,
+ * and the rest appear in the order a résumé conventionally uses. Entry order
+ * within a section is preserved from the input (already normalized by `order`
+ * upstream), so the owner's `order` field controls it — `deriveCv` never
+ * re-sorts. Empty sections are dropped so the renderer can iterate without
+ * emptiness checks.
+ *
+ * The input must already be privacy-filtered (`applyPublicPrivacyFilter`) by the
+ * caller, exactly as the public render path is: `deriveCv` does not strip
+ * anything itself, it only projects what it is given.
+ */
+
+/** The header block of a CV: identity and contact, drawn from `profile` + `contact`. */
+interface CvHeader {
+    displayName: string;
+    tagline?: string;
+    /** Human-readable location (the address `display` string), if present. */
+    location?: string;
+    bio?: string;
+    /** Email, only when the profile exposed it (privacy filter already applied). */
+    email?: string;
+    formUrl?: string;
+}
+/**
+ * One CV section, discriminated by `kind`, carrying the locale-resolved entries
+ * for that section. The entry types are reused verbatim from `LocalizedTakuhon`.
+ */
+type CvSection = {
+    kind: 'experience';
+    entries: LocalizedCareer[];
+} | {
+    kind: 'education';
+    entries: LocalizedEducation[];
+} | {
+    kind: 'skills';
+    entries: Skill[];
+} | {
+    kind: 'certifications';
+    entries: LocalizedCertification[];
+} | {
+    kind: 'publications';
+    entries: LocalizedPublication[];
+} | {
+    kind: 'honors';
+    entries: LocalizedHonor[];
+} | {
+    kind: 'courses';
+    entries: LocalizedCourse[];
+} | {
+    kind: 'patents';
+    entries: LocalizedPatent[];
+} | {
+    kind: 'languages';
+    entries: LocalizedLanguage[];
+} | {
+    kind: 'volunteering';
+    entries: LocalizedVolunteering[];
+} | {
+    kind: 'memberships';
+    entries: LocalizedMembership[];
+};
+/** Every `CvSection` discriminant, in the fixed résumé order `deriveCv` emits. */
+type CvSectionKind = CvSection['kind'];
+/** A résumé/CV view derived from a profile: a header plus ordered sections. */
+interface CvDocument {
+    /** The locale this CV was resolved at (mirrors `LocalizedTakuhon.resolvedLocale`). */
+    resolvedLocale: string;
+    header: CvHeader;
+    /** Non-empty sections only, in the fixed CV order. */
+    sections: CvSection[];
+}
+/**
+ * Project a locale-resolved profile into a {@link CvDocument}. Sections appear
+ * in a fixed résumé-conventional order and empty ones are omitted; entry order
+ * within each section is preserved from the input. Pure and deterministic.
+ */
+declare function deriveCv(localized: LocalizedTakuhon): CvDocument;
+
+/**
+ * Image-asset helpers for uploaded media (avatars, project images): magic-byte
+ * type detection, header-only dimension / frame reading, and metadata stripping
+ * (EXIF / IPTC / XMP / color profile) for the four MIME types takuhon accepts.
+ *
+ * Every function parses only the container structure — it never decodes pixel
+ * data — so the module is tiny, dependency-free, and runs identically on
+ * Cloudflare Workers, Node, and in the browser. This is the deliberate
+ * "no codec, no re-encode" approach: `security.md` §4 requires metadata removal
+ * for privacy (EXIF GPS / device data on avatars) but leaves resizing to the UI
+ * (§4.3 "aspect ratio cropped UI-side"), so no image codec is needed.
+ *
+ * AVIF is intentionally not handled yet — its ISO-BMFF metadata layout is more
+ * involved — so {@link detectImageMime} returns `null` for it and uploads of it
+ * are rejected until a later phase adds support.
+ *
+ * The functions assume well-formed input only as far as security requires:
+ * {@link detectImageMime} authenticates the type from the leading bytes (so a
+ * spoofed `Content-Type` cannot smuggle, say, an SVG), {@link readImageInfo}
+ * returns `null` when it cannot find the dimensions, and
+ * {@link stripImageMetadata} preserves the pixel data while dropping metadata
+ * segments. A truncated or malformed file is the uploader's problem — the bytes
+ * are stored and served verbatim, never decoded server-side.
+ */
+/** MIME types accepted for uploaded images (`security.md` §4.1, minus AVIF). */
+declare const ACCEPTED_IMAGE_MIME_TYPES: readonly ["image/jpeg", "image/png", "image/webp", "image/gif"];
+type AcceptedImageMime = (typeof ACCEPTED_IMAGE_MIME_TYPES)[number];
+/** Maximum accepted upload size, in bytes (`security.md` §4.3). */
+declare const MAX_IMAGE_BYTES: number;
+/** Maximum accepted width or height, in pixels (`security.md` §4.3). */
+declare const MAX_IMAGE_DIMENSION = 4096;
+/** Maximum accepted animation frame count (`security.md` §4.4). */
+declare const MAX_IMAGE_FRAMES = 100;
+/** Canonical file extension per accepted MIME, used in object keys. */
+declare const IMAGE_EXTENSIONS: Record<AcceptedImageMime, string>;
+/** Dimensions and animation frame count read from an image's container header. */
+interface ImageInfo {
+    width: number;
+    height: number;
+    /** 1 for a still image; the frame count for an animated GIF / WebP / APNG. */
+    frames: number;
+}
+/**
+ * Identify an accepted image type from its leading bytes, independent of any
+ * declared `Content-Type` (`security.md` §4.2). Returns `null` for unrecognized
+ * or unsupported (e.g. AVIF, SVG) input.
+ */
+declare function detectImageMime(bytes: Uint8Array): AcceptedImageMime | null;
+/**
+ * Read an image's dimensions and animation frame count from its container
+ * header alone (no pixel decode). Returns `null` when the structure cannot be
+ * parsed. `mime` must come from {@link detectImageMime}.
+ */
+declare function readImageInfo(bytes: Uint8Array, mime: AcceptedImageMime): ImageInfo | null;
+/**
+ * Remove metadata (EXIF / IPTC / XMP / embedded color profile / comments) from
+ * an image while preserving its pixel data, by editing only the container
+ * structure (`security.md` §4.5). `mime` must come from {@link detectImageMime}.
+ * Returns the original bytes unchanged when there is no metadata to remove.
+ */
+declare function stripImageMetadata(bytes: Uint8Array, mime: AcceptedImageMime): Uint8Array;
+
 /**
  * @takuhon/core — canonical JSON Schema, hand-written TypeScript types,
  * Ajv-backed validation, document normalization, and locale resolution for
@@ -3414,6 +3899,6 @@ declare class ConflictError extends StorageError {
  * A takuhon profile document's `schemaVersion` field must be migrate-compatible
  * with this version. See operational-lifecycle docs for the migration policy.
  */
-declare const SCHEMA_VERSION = "0.4.0";
+declare const SCHEMA_VERSION = "0.5.0";
 
-export { type Address, type AssetOptions, type AssetRecord, type Avatar, type Career, type Certification, ConflictError, type Contact, type ContentLicense, type ContentLicenseAttribution, type Course, type Education, type ExportOptions, type ExportedTakuhon, type Honor, ImportError, type Iso3166Alpha2, type IsoDateTime, type Language, type LanguageProficiency, type Link, type LinkBuiltin, type LinkCustom, type LinkType, type LocaleTag, type LocalizedAddress, type LocalizedAvatar, type LocalizedBody, type LocalizedCareer, type LocalizedCertification, type LocalizedCourse, type LocalizedEducation, type LocalizedHonor, type LocalizedLanguage, type LocalizedLink, type LocalizedLinkBuiltin, type LocalizedLinkCustom, type LocalizedMembership, type LocalizedPatent, type LocalizedProfile, type LocalizedProject, type LocalizedPublication, type LocalizedRecommendation, type LocalizedRecommendationAuthor, type LocalizedTakuhon, type LocalizedTestScore, type LocalizedTitle, type LocalizedVolunteering, type Membership, type Meta, type MetaPrivacy, type Migration, MigrationError, type NormalizedTakuhon, NotFoundError, type Patent, type PatentStatus, type Profile, type Project, type Publication, type Recommendation, type RecommendationAuthor, SCHEMA_VERSION, SUPPORTED_SCHEMA_VERSIONS, type Schema, type Settings, type Skill, type Slug, StorageError, type Takuhon, type TakuhonAssetStorage, type TakuhonStorage, type TestScore, type ValidationError, type ValidationResult, type Volunteering, type YearMonth, applyPublicPrivacyFilter, exportTakuhon, generateJsonLd, generatePersonJsonLd, generateProfilePageJsonLd, importTakuhon, migrateTakuhon, migrations, normalize, resolveLocale, schema, validate };
+export { ACCEPTED_IMAGE_MIME_TYPES, type AcceptedImageMime, type ActivitySettings, type ActivitySnapshot, type ActivityStorage, type Address, type AssetOptions, type AssetRecord, type Avatar, type Career, type Certification, type CodingTime, ConflictError, type Contact, type ContentLicense, type ContentLicenseAttribution, type ContributionCalendar, type ContributionDay, type Course, type CvDocument, type CvHeader, type CvSection, type CvSectionKind, type Education, type ExportOptions, type ExportedTakuhon, type Honor, IMAGE_EXTENSIONS, type ImageInfo, ImportError, type Iso3166Alpha2, type IsoDateTime, type Language, type LanguageBreakdown, type LanguageProficiency, type Link, type LinkBuiltin, type LinkCustom, type LinkType, type LocaleTag, type LocalizedAddress, type LocalizedAvatar, type LocalizedBody, type LocalizedCareer, type LocalizedCertification, type LocalizedCourse, type LocalizedEducation, type LocalizedHonor, type LocalizedLanguage, type LocalizedLink, type LocalizedLinkBuiltin, type LocalizedLinkCustom, type LocalizedMembership, type LocalizedPatent, type LocalizedProfile, type LocalizedProject, type LocalizedPublication, type LocalizedRecommendation, type LocalizedRecommendationAuthor, type LocalizedTakuhon, type LocalizedTestScore, type LocalizedTitle, type LocalizedVolunteering, MAX_IMAGE_BYTES, MAX_IMAGE_DIMENSION, MAX_IMAGE_FRAMES, type Membership, type Meta, type MetaPrivacy, type Migration, MigrationError, type NormalizedTakuhon, NotFoundError, type Patent, type PatentStatus, type Profile, type Project, type Publication, RANK_FULL_CODING_HOURS, RANK_FULL_CONTRIBUTIONS, RANK_TIER_THRESHOLDS, type RankInput, type RankTier, type RankTierLabel, type Recommendation, type RecommendationAuthor, SCHEMA_VERSION, SUPPORTED_SCHEMA_VERSIONS, type Schema, type Settings, type Skill, type Slug, StorageError, type Takuhon, type TakuhonAssetStorage, type TakuhonStorage, type TestScore, type ValidationError, type ValidationResult, type Volunteering, type YearMonth, applyPublicPrivacyFilter, computeLanguagePercentages, deriveCv, deriveRankTier, detectImageMime, exportTakuhon, formatCodingTime, generateJsonLd, generatePersonJsonLd, generateProfilePageJsonLd, importTakuhon, isActivitySnapshot, migrateTakuhon, migrations, normalize, readImageInfo, renderActivitySvg, resolveLocale, schema, stripImageMetadata, validate };