@riverbankcms/sdk 0.77.0 → 0.78.0

package/dist/_dts/content-model/src/templates/editorState.d.ts

@@ -0,0 +1,25 @@
+import type { TemplateBindingValue } from './types';
+export type TemplateEditorBindingDescriptor = TemplateBindingValue | Record<string, unknown>;
+export type TemplateEditorBindings = Record<string, TemplateEditorBindingDescriptor>;
+export type TemplateEditorBlockBindings = Record<string, TemplateEditorBindings>;
+export type TemplateEditorBlockBindingSource = Readonly<{
+    id: string;
+    scope: string;
+    bindings?: Record<string, unknown> | null;
+}>;
+export type ParsedTemplateEditorBindings = Readonly<{
+    ok: true;
+    bindings: TemplateEditorBindings;
+}> | Readonly<{
+    ok: false;
+    message: string;
+}>;
+export declare function normalizeTemplateEditorBindings(bindings: Record<string, unknown> | null | undefined): TemplateEditorBindings;
+export declare function serializeTemplateEditorBindingsJson(bindings: TemplateEditorBindings): string;
+export declare function parseTemplateEditorBindingsJson(jsonValue: string): ParsedTemplateEditorBindings;
+export declare function mergeTemplateBindingEdits(currentBindings: TemplateEditorBindings, editedBindings: TemplateEditorBindings): TemplateEditorBindings;
+export declare function setTemplateEditorBinding(bindings: TemplateEditorBindings, propId: string, binding: TemplateEditorBindingDescriptor): TemplateEditorBindings;
+export declare function removeTemplateEditorBinding(bindings: TemplateEditorBindings, propId: string): TemplateEditorBindings;
+export declare function createEntryTemplateBindingRecords(blocks: readonly TemplateEditorBlockBindingSource[]): TemplateEditorBlockBindings;
+export declare function setTemplateBlockBinding(allBindings: TemplateEditorBlockBindings, blockId: string, propId: string, binding: TemplateEditorBindingDescriptor): TemplateEditorBlockBindings;
+export declare function removeTemplateBlockBinding(allBindings: TemplateEditorBlockBindings, blockId: string, propId: string): TemplateEditorBlockBindings;

package/dist/_dts/core/src/csv-cells.d.ts

@@ -0,0 +1,10 @@
+import type { CsvCell } from './csv-types';
+export declare const csvEmptyCell: () => CsvCell;
+export declare const csvTextCell: (value: string | null | undefined) => CsvCell;
+export declare const csvIntegerCell: (value: number | null | undefined) => CsvCell;
+export declare const csvDecimalCell: (value: number | null | undefined, decimals: number) => CsvCell;
+export declare const csvMoneyCentsCell: (cents: number | null | undefined, currency: string | null | undefined) => CsvCell;
+export declare const csvIsoDateCell: (value: string | null | undefined) => CsvCell;
+export declare const csvIsoDateTimeCell: (value: string | null | undefined) => CsvCell;
+export declare const csvBooleanCell: (value: boolean | null | undefined) => CsvCell;
+export declare function formatCsvCell(cell: CsvCell): string;

package/dist/_dts/core/src/csv-date-filter.d.ts

@@ -0,0 +1,27 @@
+import type { CsvExportDatePolicy, CsvExportId, ExportDateBasis, ExportDateFilterError, ExportDateRange, ResolvedExportDateWindow } from './csv-types';
+export type ResolveExportDateWindowInput = Readonly<{
+    exportId: CsvExportId;
+    policy: CsvExportDatePolicy;
+    range: ExportDateRange;
+    requestedBasis?: ExportDateBasis;
+    timeZone: string;
+    today?: Date;
+}>;
+export type ResolveExportDateWindowInputFor<Basis extends ExportDateBasis> = Readonly<{
+    exportId: CsvExportId;
+    policy: CsvExportDatePolicy<Basis>;
+    range: ExportDateRange;
+    requestedBasis?: Basis;
+    timeZone: string;
+    today?: Date;
+}>;
+export type ResolveExportDateWindowResult<Basis extends ExportDateBasis = ExportDateBasis> = Readonly<{
+    ok: true;
+    window: ResolvedExportDateWindow<Basis>;
+}> | Readonly<{
+    ok: false;
+    error: ExportDateFilterError;
+}>;
+export declare function resolveExportDateWindow<Basis extends ExportDateBasis>(input: ResolveExportDateWindowInputFor<Basis>): ResolveExportDateWindowResult<Basis>;
+export declare function resolveExportDateWindow(input: ResolveExportDateWindowInput): ResolveExportDateWindowResult;
+export declare function describeExportDateBasis(basis: ExportDateBasis): string;

package/dist/_dts/core/src/csv-escape.d.ts

@@ -0,0 +1 @@
+export declare function csvEscape(value: string): string;

package/dist/_dts/core/src/csv-filename.d.ts

@@ -0,0 +1,18 @@
+import type { SafeCsvFilename } from './csv-types';
+export type SafeCsvFilenameResult = Readonly<{
+    ok: true;
+    filename: SafeCsvFilename;
+}> | Readonly<{
+    ok: false;
+    filename: string;
+}>;
+export declare function toSafeCsvFilename(value: string): SafeCsvFilenameResult;
+export declare function assertSafeCsvFilename(value: string): SafeCsvFilename;
+export declare const unsafeCsvFilename: typeof assertSafeCsvFilename;
+export declare function csvFilenameDateRange(input: Readonly<{
+    from?: string | null;
+    to?: string | null;
+    fallback?: string | null;
+    prefix?: string | null;
+}>): string;
+export declare function contentDispositionForCsv(filename: SafeCsvFilename): string;

package/dist/_dts/core/src/csv-render.d.ts

@@ -0,0 +1,4 @@
+import type { CsvColumn, CsvColumnSensitivity, CsvRenderResult, RenderCsvInput, RenderCsvError } from './csv-types';
+export declare function renderCsvExport<Row, Options>(input: RenderCsvInput<Row, Options>): CsvRenderResult;
+export declare function collectCsvColumnSensitivities<Row>(columns: readonly CsvColumn<Row>[]): ReadonlySet<CsvColumnSensitivity>;
+export declare function describeRenderCsvError(error: RenderCsvError): string;

package/dist/_dts/core/src/csv-types.d.ts

@@ -0,0 +1,116 @@
+import type { Brand, MoneyDateString } from './branded';
+export type CsvExportId = Brand<string, 'CsvExportId'>;
+export type CsvColumnKey = Brand<string, 'CsvColumnKey'>;
+export type SafeCsvFilename = Brand<string, 'SafeCsvFilename'>;
+export type ExportRowLimit = Brand<number, 'ExportRowLimit'>;
+export type CsvColumnSensitivity = 'standard' | 'personal' | 'financial' | 'sensitive';
+export type CsvCell = Readonly<{
+    kind: 'empty';
+}> | Readonly<{
+    kind: 'text';
+    value: string;
+}> | Readonly<{
+    kind: 'integer';
+    value: number;
+}> | Readonly<{
+    kind: 'decimal';
+    value: number;
+    decimals: number;
+}> | Readonly<{
+    kind: 'moneyCents';
+    cents: number;
+    currency: string;
+}> | Readonly<{
+    kind: 'isoDate';
+    value: string;
+}> | Readonly<{
+    kind: 'isoDateTime';
+    value: string;
+}> | Readonly<{
+    kind: 'boolean';
+    value: boolean;
+}>;
+export type CsvColumn<Row> = Readonly<{
+    key: CsvColumnKey;
+    header: string;
+    sensitivity: CsvColumnSensitivity;
+    cell: (row: Row) => CsvCell;
+}>;
+export type CsvExportDefinition<Row, Options> = Readonly<{
+    id: CsvExportId;
+    filename: (options: Options) => string;
+    columns: (options: Options) => readonly CsvColumn<Row>[];
+    maxRows: ExportRowLimit;
+}>;
+export type RenderCsvInput<Row, Options> = Readonly<{
+    definition: CsvExportDefinition<Row, Options>;
+    rows: readonly Row[];
+    options: Options;
+}>;
+export type RenderCsvError = Readonly<{
+    tag: 'too_many_rows';
+    maxRows: number;
+    actualRows: number;
+}> | Readonly<{
+    tag: 'duplicate_column_key';
+    key: string;
+}> | Readonly<{
+    tag: 'invalid_filename';
+    filename: string;
+}>;
+export type CsvRenderResult = Readonly<{
+    ok: true;
+    csv: string;
+    filename: SafeCsvFilename;
+    rowCount: number;
+    sensitivities: ReadonlySet<CsvColumnSensitivity>;
+}> | Readonly<{
+    ok: false;
+    error: RenderCsvError;
+}>;
+export type ExportDateBasis = 'created_at' | 'scheduled_at' | 'cancelled_at' | 'paid_at' | 'processed_at';
+export type ExportDatePreset = '7d' | '30d' | '90d' | '365d' | 'all';
+export type ExportDateRange = Readonly<{
+    kind: 'preset';
+    preset: ExportDatePreset;
+}> | Readonly<{
+    kind: 'custom';
+    from?: string;
+    to?: string;
+}>;
+export type ResolvedExportDateWindow<Basis extends ExportDateBasis = ExportDateBasis> = Readonly<{
+    basis: Basis;
+    from: MoneyDateString;
+    to: MoneyDateString;
+    timeZone: string;
+}>;
+export type CsvExportDatePolicy<Basis extends ExportDateBasis = ExportDateBasis> = Readonly<{
+    supportedDateBases: readonly Basis[];
+    defaultDateBasis: Basis;
+}>;
+export type ExportDateFilterError = Readonly<{
+    tag: 'unsupported_date_basis';
+    basis: ExportDateBasis;
+    exportId: CsvExportId;
+}> | Readonly<{
+    tag: 'invalid_date';
+    field: 'from' | 'to';
+    value: string;
+}> | Readonly<{
+    tag: 'partial_custom_range';
+}> | Readonly<{
+    tag: 'invalid_date_range';
+    from: MoneyDateString;
+    to: MoneyDateString;
+}>;
+export type MoneyExportCurrencyPolicy = Readonly<{
+    kind: 'single_currency';
+    currency: string;
+}> | Readonly<{
+    kind: 'group_by_currency';
+}> | Readonly<{
+    kind: 'reject_mixed_currency';
+}>;
+export declare function asCsvExportId(value: string): CsvExportId;
+export declare function asCsvColumnKey(value: string): CsvColumnKey;
+export declare function asExportRowLimit(value: number): ExportRowLimit;

package/dist/_dts/core/src/currency-format.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Format minor currency units using the locale customers expect for that code.
+ */
+export declare function formatCurrencyAmount(amountCents: number, currency: string): string;

package/dist/_dts/core/src/demo-capability-policy.d.ts

@@ -0,0 +1,29 @@
+import { type DemoCapability } from './index';
+export declare const demoSurfaceClassificationValues: readonly ["allowed", "blocked-hidden", "blocked-disabled", "internal-only", "needs-classification"];
+export type DemoSurfaceClassification = (typeof demoSurfaceClassificationValues)[number];
+export type DemoRestrictionReason = 'surface_not_classified' | 'dangerous_surface' | 'internal_only' | 'claim_not_active';
+export type DemoCapabilityDecision = Readonly<{
+    allowed: true;
+    classification: Extract<DemoSurfaceClassification, 'allowed'>;
+}> | Readonly<{
+    allowed: false;
+    classification: DemoSurfaceClassification;
+    reason: DemoRestrictionReason;
+    surface: DemoCapability;
+}>;
+export type DemoClaimAccessState = Readonly<{
+    kind: 'active';
+}> | Readonly<{
+    kind: 'expired';
+}> | Readonly<{
+    kind: 'released';
+}> | Readonly<{
+    kind: 'missing';
+}>;
+export type DemoCapabilityPolicyInput = Readonly<{
+    surface: DemoCapability;
+    classification: DemoSurfaceClassification;
+    claim: DemoClaimAccessState;
+}>;
+/** Evaluates a classified demo mutation surface and fails closed for inactive claims or unknown surfaces. */
+export declare function evaluateDemoCapability(input: DemoCapabilityPolicyInput): DemoCapabilityDecision;

package/dist/_dts/core/src/demo-claim-access.d.ts

@@ -0,0 +1,14 @@
+import type { DemoClaimAccessState } from './demo-capability-policy';
+import type { DemoClaimStatus, DemoInstanceStatus } from './demo-lifecycle-status';
+export type DemoClaimAccessInstance = Readonly<{
+    status: DemoInstanceStatus;
+}>;
+export type DemoClaimAccessClaim = Readonly<{
+    status: DemoClaimStatus;
+    expiresAt: string;
+}> | null;
+export declare function deriveDemoClaimAccessState(input: Readonly<{
+    instance: DemoClaimAccessInstance;
+    claim: DemoClaimAccessClaim;
+    now: Date;
+}>): DemoClaimAccessState;

package/dist/_dts/core/src/demo-lifecycle-status.d.ts

@@ -0,0 +1,11 @@
+export declare const demoBlueprintStatusValues: readonly ["draft", "published", "archived"];
+export type DemoBlueprintStatus = (typeof demoBlueprintStatusValues)[number];
+export declare const demoInstanceStatusValues: readonly ["warming", "available", "claimed", "expired", "recycling", "failed"];
+export type DemoInstanceStatus = (typeof demoInstanceStatusValues)[number];
+export declare const demoClaimStatusValues: readonly ["active", "expired", "released"];
+export type DemoClaimStatus = (typeof demoClaimStatusValues)[number];
+export declare const demoBlueprintArtifactKindValues: readonly ["site_backup", "manual_snapshot"];
+export type DemoBlueprintArtifactKind = (typeof demoBlueprintArtifactKindValues)[number];
+export declare function narrowDemoInstanceStatus(value: string): DemoInstanceStatus;
+export declare function narrowDemoClaimStatus(value: string): DemoClaimStatus;
+export declare function narrowDemoBlueprintArtifactKind(value: string): DemoBlueprintArtifactKind;

package/dist/_dts/core/src/demo-runtime.d.ts

@@ -0,0 +1,47 @@
+export declare const RIVERBANK_RUNTIME_ENV_VAR = "RIVERBANK_RUNTIME_ENV";
+export declare const riverbankRuntimeEnvValues: readonly ["production", "staging", "demo"];
+export type RiverbankRuntimeEnv = (typeof riverbankRuntimeEnvValues)[number];
+export type RiverbankRuntime = Readonly<{
+    kind: 'production';
+    demoAllowed: false;
+}> | Readonly<{
+    kind: 'staging';
+    demoAllowed: false;
+}> | Readonly<{
+    kind: 'demo';
+    demoAllowed: true;
+}>;
+export type RiverbankRuntimeResolution = Readonly<{
+    kind: 'resolved';
+    runtime: RiverbankRuntime;
+}> | Readonly<{
+    kind: 'invalid';
+    error: RiverbankRuntimeResolutionError;
+}>;
+export type RiverbankRuntimeResolutionError = Readonly<{
+    kind: 'missing_runtime_env';
+    envVar: typeof RIVERBANK_RUNTIME_ENV_VAR;
+}> | Readonly<{
+    kind: 'unsupported_runtime_env';
+    envVar: typeof RIVERBANK_RUNTIME_ENV_VAR;
+    rawValue: string;
+    normalizedValue: string;
+    supportedValues: readonly RiverbankRuntimeEnv[];
+}>;
+export type DemoRuntimeRequirement = Readonly<{
+    allowed: true;
+    runtime: Extract<RiverbankRuntime, {
+        kind: 'demo';
+    }>;
+}> | Readonly<{
+    allowed: false;
+    reason: DemoRuntimeRequirementDenialReason;
+    runtime?: Exclude<RiverbankRuntime, {
+        kind: 'demo';
+    }>;
+    error?: RiverbankRuntimeResolutionError;
+}>;
+export type DemoRuntimeRequirementDenialReason = 'missing_runtime_env' | 'unsupported_runtime_env' | 'not_demo_runtime';
+export declare function parseRiverbankRuntimeEnv(rawValue: string | null | undefined): RiverbankRuntimeResolution;
+export declare function resolveRiverbankRuntimeEnv(env: Readonly<Record<string, string | undefined>>): RiverbankRuntimeResolution;
+export declare function requireDemoRuntime(resolution: RiverbankRuntimeResolution): DemoRuntimeRequirement;

package/dist/_dts/core/src/duration.d.ts

@@ -0,0 +1,14 @@
+export type DurationUnit = 'minutes' | 'hours' | 'days' | 'weeks';
+export declare const DURATION_UNIT_MINUTES: Record<DurationUnit, number>;
+export declare function formatDurationUnitLabel(unit: DurationUnit, count: number): string;
+/**
+ * Picks the coarsest allowed unit that cleanly divides `minutes`. Falls back
+ * to the smallest allowed unit when no clean divisor exists.
+ */
+export declare function pickDurationDisplayUnit(minutes: number, allowed: readonly DurationUnit[]): DurationUnit;
+/**
+ * Guarantees the widget invariant `displayValue x unit === storedMinutes` is
+ * representable by prepending minutes when no caller-provided unit divides.
+ */
+export declare function expandAllowedDurationUnits(value: number, base: readonly DurationUnit[]): readonly DurationUnit[];
+export declare function clampDurationMinutes(value: number, min: number | undefined, max: number | undefined): number;

package/dist/_dts/core/src/email-format.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Mask an email address for display purposes.
+ * Shows first and last characters of the local part with asterisks in between.
+ * Example: "john.doe@example.com" -> "j******e@example.com"
+ * For 1-2 character local parts, preserve only the first character and append "***"
+ * so very short addresses do not leak disproportionate detail.
+ */
+export declare function maskEmail(email: string): string;
+export declare function maskEmail(email: null): null;
+export declare function maskEmail(email: string | null): string | null;

package/dist/_dts/core/src/field-errors.d.ts

@@ -0,0 +1 @@
+export declare function clearFieldError<TField extends string, TErrors extends Partial<Record<TField, string>>>(errors: TErrors, field: TField): TErrors;

package/dist/_dts/core/src/form-submission-preview.d.ts

@@ -0,0 +1,24 @@
+type SchemaField = {
+    id: string;
+    label?: string | null;
+    type?: string | null;
+    required?: boolean | null;
+};
+type SubmissionRow = {
+    dataJson: Record<string, unknown> | null;
+};
+export type SubmissionPreviewField = {
+    id: string;
+    label: string;
+    type: string;
+};
+export declare const FORM_SUBMISSION_PSEUDO_FIELD_ID = "submission";
+export declare const HIDDEN_FIELD_IDS: Set<string>;
+export declare function selectSubmissionPreviewFields(schemaFields: unknown, submissions: SubmissionRow[]): SubmissionPreviewField[];
+export declare function humanizeSubmissionFieldKey(input: string): string;
+export declare function orderSubmissionFields(schemaFields: SchemaField[] | undefined, data: Record<string, unknown> | null): {
+    id: string;
+    label: string;
+    value: unknown;
+}[];
+export {};

package/dist/_dts/core/src/index.d.ts

@@ -1,5 +1,10 @@
 export * from "./branded";
 export * from "./date-math";
+export * from "./duration";
+export * from "./demo-capability-policy";
+export * from "./demo-claim-access";
+export * from "./demo-lifecycle-status";
+export * from "./demo-runtime";
 export * from "./collections";
 export * from "./event-pricing";
 export * from "./money-input";
@@ -21,5 +26,20 @@ export * from "./sensitive-collection";
 export * from "./assertNever";
 export * from "./participants";
 export * from "./participant-identity";
+export * from "./public-url-validation";
+export * from "./number-input";
+export * from "./field-errors";
+export * from "./form-submission-preview";
+export * from "./csv-cells";
+export * from "./csv-date-filter";
+export * from "./csv-escape";
+export * from "./csv-filename";
+export * from "./csv-render";
+export * from "./csv-types";
+export * from "./currency-format";
+export * from "./email-format";
+export * from "./slug";
+export * from "./string";
+export * from "./uuid";
 export { disabledSelection, enabledSelection, plannerNoChange, plannerPatch, plannerUpdate, resolvePlanningDateInput, resolvePlanningNow, resolvePlanningNowDate, systemPlanningClock, } from "./planner";
 export type { DisabledSelection, EnabledSelection, OptionalSelection, PlannerNoChange, PlannerPatch, PlannerUpdate, PlanningClock, PlanningDateInput, PlanningTimeOptions, } from "./planner";

package/dist/_dts/core/src/number-input.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Numeric form-input parsing helpers with preserve-prev semantics on
+ * NaN/empty/negative. Use these in `NumberInput.onChange` so empty input
+ * doesn't silently rewrite the user's value to 0.
+ *
+ * The caller skips the dispatch when `null` is returned; the input box
+ * keeps showing whatever the user typed (it's an uncontrolled native
+ * input from React's perspective until the next state change), and the
+ * dirty/saved state stays consistent.
+ */
+/**
+ * Parse a `valueAsNumber` (from `<input type="number">`) into a finite
+ * non-negative integer, or `null` if the value is empty / NaN / negative.
+ * Fractional input is `Math.trunc`'d to an integer.
+ */
+export declare function parseFiniteNonNegativeInt(value: number): number | null;
+/**
+ * Parse a `valueAsNumber` into an integer bounded inclusive by `[min, max]`.
+ * Returns `null` for out-of-range or non-finite input — same preserve-prev
+ * pattern as `parseFiniteNonNegativeInt`.
+ */
+export declare function parseBoundedInt(value: number, min: number, max: number): number | null;

package/dist/_dts/core/src/public-url-validation.d.ts

@@ -0,0 +1,12 @@
+export type PublicUrlProtocol = 'http:' | 'https:';
+export type PublicUrlPortPolicy = 'standard-only' | 'any-valid';
+export type PublicUrlValidationOptions = Readonly<{
+    allowedProtocols: readonly PublicUrlProtocol[];
+    portPolicy: PublicUrlPortPolicy;
+    errorFactory?: (message: string) => Error;
+}>;
+export declare function buildPublicUrlValidationError(message: string, errorFactory?: (message: string) => Error): Error;
+export declare function isIpAddress(value: string): boolean;
+export declare function isPrivateIp(ip: string): boolean;
+export declare function assertAllowedPublicHostname(hostname: string, errorFactory?: (message: string) => Error): void;
+export declare function assertAllowedPublicUrl(raw: string, options: PublicUrlValidationOptions): URL;

package/dist/_dts/core/src/slug.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Convert a string to a URL-safe slug
+ *
+ * @param text - The text to slugify
+ * @returns URL-safe slug (lowercase, alphanumeric + hyphens)
+ *
+ * @example
+ * slugify("Initial Consultation") // "initial-consultation"
+ * slugify("90-Minute Deep Tissue") // "90-minute-deep-tissue"
+ * slugify("Reiki & Energy Healing") // "reiki-energy-healing"
+ */
+export declare function slugify(text: string): string;
+/**
+ * Generate a unique slug by appending a number if needed
+ *
+ * @param baseSlug - The base slug to make unique
+ * @param existingSlugs - Array of slugs already in use
+ * @returns Unique slug (adds -2, -3, etc. if needed)
+ *
+ * @example
+ * makeUniqueSlug("consultation", ["consultation"])
+ * // Returns: "consultation-2"
+ *
+ * makeUniqueSlug("consultation", ["consultation", "consultation-2"])
+ * // Returns: "consultation-3"
+ */
+export declare function makeUniqueSlug(baseSlug: string, existingSlugs: string[]): string;
+/**
+ * Generate a slug from text and ensure it's unique
+ *
+ * @param text - The text to slugify
+ * @param existingSlugs - Array of slugs already in use
+ * @returns Unique URL-safe slug
+ *
+ * @example
+ * generateUniqueSlug("Initial Consultation", ["initial-consultation"])
+ * // Returns: "initial-consultation-2"
+ */
+export declare function generateUniqueSlug(text: string, existingSlugs: string[]): string;

package/dist/_dts/core/src/string.d.ts

@@ -0,0 +1,19 @@
+/**
+ * String utilities
+ */
+/**
+ * Return the string value when the input is already a string, otherwise null.
+ */
+export declare function asNullableString(value: unknown): string | null;
+/**
+ * Return a non-empty string value, otherwise null.
+ */
+export declare function asNonEmptyStringOrNull(value: unknown): string | null;
+/**
+ * Trim a user-entered string and collapse blank values to null.
+ */
+export declare function trimmedStringOrNull(value: string | null | undefined): string | null;
+/**
+ * Capitalize the first character of a string
+ */
+export declare function capitalize(str: string): string;

package/dist/_dts/core/src/uuid.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Validates whether a string matches UUID v4 format
+ * Format: 8-4-4-4-12 hexadecimal digits
+ * Example: 550e8400-e29b-41d4-a716-446655440000
+ */
+export declare function isValidUuid(str: string): boolean;