@prismicio/types-internal 3.7.0 → 3.8.0

package/lib/customtypes/widgets/slices/SliceWidget.d.ts

@@ -0,0 +1,327 @@
+import * as t from "io-ts";
+export declare const SliceWidget: t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Group">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    icon: t.StringC;
+    description: t.StringC;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        repeat: t.BooleanC;
+        fields: t.RecordC<t.Type<string, string, unknown>, t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+            type: t.LiteralC<"Color">;
+        }>, t.PartialC<{
+            fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+            config: t.ExactC<t.PartialC<{
+                label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+                placeholder: t.StringC;
+            }>>;
+        }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+            type: t.LiteralC<"Boolean">;
+        }>, t.PartialC<{
+            config: t.ExactC<t.PartialC<{
+                label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+                default_value: t.BooleanC;
+                placeholder_true: t.StringC;
+                placeholder_false: t.StringC;
+            }>>;
+        }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+            type: t.LiteralC<"Embed">;
+        }>, t.PartialC<{
+            fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+            config: t.ExactC<t.PartialC<{
+                label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+                placeholder: t.StringC;
+                useAsTitle: t.BooleanC;
+            }>>;
+        }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+            type: t.LiteralC<"GeoPoint">;
+        }>, t.PartialC<{
+            fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+            config: t.ExactC<t.PartialC<{
+                label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+            }>>;
+        }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+            type: t.LiteralC<"Date">;
+        }>, t.PartialC<{
+            fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+            config: t.ExactC<t.PartialC<{
+                label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+                placeholder: t.StringC;
+                default: t.StringC;
+            }>>;
+        }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+            type: t.LiteralC<"Number">;
+        }>, t.PartialC<{
+            fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+            config: t.ExactC<t.PartialC<{
+                label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+                placeholder: t.StringC;
+                min: t.UnionC<[t.NumberC, import("io-ts-types").NumberFromStringC]>;
+                max: t.UnionC<[t.NumberC, import("io-ts-types").NumberFromStringC]>;
+                step: t.UnionC<[t.NumberC, import("io-ts-types").NumberFromStringC]>;
+            }>>;
+        }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+            type: t.LiteralC<"Range">;
+        }>, t.PartialC<{
+            fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+            config: t.ExactC<t.PartialC<{
+                label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+                placeholder: t.StringC;
+                min: t.UnionC<[t.NumberC, import("io-ts-types").NumberFromStringC]>;
+                max: t.UnionC<[t.NumberC, import("io-ts-types").NumberFromStringC]>;
+                step: t.UnionC<[t.NumberC, import("io-ts-types").NumberFromStringC]>;
+            }>>;
+        }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+            type: t.LiteralC<"StructuredText">;
+        }>, t.PartialC<{
+            fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+            config: t.ExactC<t.PartialC<{
+                label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+                placeholder: t.StringC;
+                useAsTitle: t.BooleanC;
+                single: t.Type<string, string, unknown>;
+                multi: t.Type<string, string, unknown>;
+                imageConstraint: t.PartialC<{
+                    width: t.Type<number | null, unknown, unknown>;
+                    height: t.Type<number | null, unknown, unknown>;
+                }>;
+                labels: t.Type<readonly string[], object, unknown>;
+                allowTargetBlank: t.BooleanC;
+            }>>;
+        }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+            type: t.LiteralC<"Select">;
+        }>, t.PartialC<{
+            fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+            config: t.ExactC<t.PartialC<{
+                label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+                placeholder: t.StringC;
+                default_value: t.StringC;
+                options: t.ReadonlyArrayC<t.UnionC<[t.StringC, t.Type<string, string, unknown>, t.Type<string, string, unknown>]>>;
+            }>>;
+        }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+            type: t.LiteralC<"Separator">;
+        }>, t.PartialC<{
+            config: t.ExactC<t.PartialC<{
+                label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+            }>>;
+        }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+            type: t.LiteralC<"Text">;
+        }>, t.PartialC<{
+            fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+            config: t.ExactC<t.PartialC<{
+                label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+                useAsTitle: t.BooleanC;
+                placeholder: t.StringC;
+            }>>;
+        }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+            type: t.LiteralC<"Timestamp">;
+        }>, t.PartialC<{
+            fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+            config: t.ExactC<t.PartialC<{
+                label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+                placeholder: t.StringC;
+                default: t.StringC;
+            }>>;
+        }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+            type: t.LiteralC<"Link">;
+        }>, t.PartialC<{
+            fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+            config: t.ExactC<t.PartialC<{
+                label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+                useAsTitle: t.BooleanC;
+                placeholder: t.StringC;
+                select: t.UnionC<[t.LiteralC<"media">, t.LiteralC<"document">, t.LiteralC<"web">, t.NullC]>;
+                customtypes: t.ReadonlyArrayC<t.StringC>;
+                masks: t.Type<readonly string[], object, unknown>;
+                tags: t.Type<readonly string[], object, unknown>;
+                allowTargetBlank: t.BooleanC;
+            }>>;
+        }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+            type: t.LiteralC<"Image">;
+        }>, t.PartialC<{
+            fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+            config: t.ExactC<t.PartialC<{
+                label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+                placeholder: t.StringC;
+                constraint: t.PartialC<{
+                    width: t.Type<number | null, unknown, unknown>;
+                    height: t.Type<number | null, unknown, unknown>;
+                }>;
+                thumbnails: t.ReadonlyArrayC<t.ExactC<t.IntersectionC<[t.TypeC<{
+                    name: t.StringC;
+                }>, t.PartialC<{
+                    width: t.Type<number | null, unknown, unknown>;
+                    height: t.Type<number | null, unknown, unknown>;
+                }>]>>>;
+            }>>;
+        }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+            type: t.LiteralC<"IntegrationFields">;
+        }>, t.PartialC<{
+            fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+            config: t.ExactC<t.PartialC<{
+                label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+                placeholder: t.StringC;
+                catalog: t.StringC;
+            }>>;
+        }>]>>]>>;
+    }>>;
+}>]>>, t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Color">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Boolean">;
+}>, t.PartialC<{
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        default_value: t.BooleanC;
+        placeholder_true: t.StringC;
+        placeholder_false: t.StringC;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Embed">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        useAsTitle: t.BooleanC;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"GeoPoint">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Date">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        default: t.StringC;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Number">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        min: t.UnionC<[t.NumberC, import("io-ts-types").NumberFromStringC]>;
+        max: t.UnionC<[t.NumberC, import("io-ts-types").NumberFromStringC]>;
+        step: t.UnionC<[t.NumberC, import("io-ts-types").NumberFromStringC]>;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Range">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        min: t.UnionC<[t.NumberC, import("io-ts-types").NumberFromStringC]>;
+        max: t.UnionC<[t.NumberC, import("io-ts-types").NumberFromStringC]>;
+        step: t.UnionC<[t.NumberC, import("io-ts-types").NumberFromStringC]>;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"StructuredText">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        useAsTitle: t.BooleanC;
+        single: t.Type<string, string, unknown>;
+        multi: t.Type<string, string, unknown>;
+        imageConstraint: t.PartialC<{
+            width: t.Type<number | null, unknown, unknown>;
+            height: t.Type<number | null, unknown, unknown>;
+        }>;
+        labels: t.Type<readonly string[], object, unknown>;
+        allowTargetBlank: t.BooleanC;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Select">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        default_value: t.StringC;
+        options: t.ReadonlyArrayC<t.UnionC<[t.StringC, t.Type<string, string, unknown>, t.Type<string, string, unknown>]>>;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Separator">;
+}>, t.PartialC<{
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Text">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        useAsTitle: t.BooleanC;
+        placeholder: t.StringC;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Timestamp">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        default: t.StringC;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Link">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        useAsTitle: t.BooleanC;
+        placeholder: t.StringC;
+        select: t.UnionC<[t.LiteralC<"media">, t.LiteralC<"document">, t.LiteralC<"web">, t.NullC]>;
+        customtypes: t.ReadonlyArrayC<t.StringC>;
+        masks: t.Type<readonly string[], object, unknown>;
+        tags: t.Type<readonly string[], object, unknown>;
+        allowTargetBlank: t.BooleanC;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Image">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        constraint: t.PartialC<{
+            width: t.Type<number | null, unknown, unknown>;
+            height: t.Type<number | null, unknown, unknown>;
+        }>;
+        thumbnails: t.ReadonlyArrayC<t.ExactC<t.IntersectionC<[t.TypeC<{
+            name: t.StringC;
+        }>, t.PartialC<{
+            width: t.Type<number | null, unknown, unknown>;
+            height: t.Type<number | null, unknown, unknown>;
+        }>]>>>;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"IntegrationFields">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        catalog: t.StringC;
+    }>>;
+}>]>>]>]>;
+export declare type SliceWidget = t.TypeOf<typeof SliceWidget>;
+export declare type SliceFieldTypes = SliceWidget["type"];

package/lib/customtypes/widgets/slices/SliceWidget.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SliceWidget = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const Group_1 = require("../Group");
+const nestable_1 = require("../nestable");
+exports.SliceWidget = t.union([Group_1.Group, nestable_1.NestableWidget]);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "3.7.0",
+	"version": "3.8.0",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",

package/src/content/fields/nestable/LinkContent.ts

@@ -26,30 +26,11 @@ import { either } from "fp-ts"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 import { withFallback } from "io-ts-types"
-import { v4 as uuid, validate as validateUuid } from "uuid"
 
 import { NonEmptyString, StringOrNull } from "../../../validators"
 import { nullable } from "../../../validators/function"
 import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx"
-import { hasContentType } from "../../utils"
-
-const isUuid = (input: unknown): input is string =>
-	typeof input === "string" && validateUuid(input)
-
-const uuidWithFallback = new t.Type<string, string, unknown>(
-	"UUID",
-	isUuid,
-	(u, c) => {
-		if (typeof u === "undefined") return t.success(uuid())
-		if (isUuid(u)) return t.success(u)
-		return t.failure(u, c)
-	},
-	t.identity,
-)
-
-function withKey<C extends t.Mixed>(codec: C) {
-	return t.intersection([t.strict({ key: uuidWithFallback }), codec])
-}
+import { hasContentType, withKey } from "../../utils"
 
 // ImageLink.
 

package/src/content/fields/nestable/TableContent.ts

@@ -11,7 +11,7 @@ import {
 	TableCell as TableCellModel,
 } from "../../../customtypes"
 import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx"
-import { hasContentType } from "../../utils"
+import { hasContentType, withKey } from "../../utils"
 import { RichTextContent, RichTextLegacyContent } from "./RichTextContent"
 
 export const TableContentType = "TableContent"
@@ -19,22 +19,26 @@ export const TableContentType = "TableContent"
 export const isTableContent = (u: unknown): u is TableContent =>
 	hasContentType(u) && u.__TYPE__ === TableContentType
 
-const TableCell = t.intersection([
-	t.strict({
-		type: t.union([t.literal("tableHeader"), t.literal("tableCell")]),
-		content: RichTextContent,
-	}),
-	t.exact(
-		t.partial({
-			columnWidth: t.number,
+const TableCell = withKey(
+	t.intersection([
+		t.strict({
+			type: t.union([t.literal("tableHeader"), t.literal("tableCell")]),
+			content: RichTextContent,
 		}),
-	),
-])
+		t.exact(
+			t.partial({
+				columnWidth: t.number,
+			}),
+		),
+	]),
+)
 
-const TableRow = t.strict({
-	type: t.literal("tableRow"),
-	content: t.array(TableCell),
-})
+const TableRow = withKey(
+	t.strict({
+		type: t.literal("tableRow"),
+		content: t.array(TableCell),
+	}),
+)
 
 export const TableContent = t.strict({
 	__TYPE__: t.literal(TableContentType),
@@ -44,22 +48,26 @@ export type TableContent = t.TypeOf<typeof TableContent>
 
 // Legacy.
 
-const TableCellLegacy = t.intersection([
-	t.strict({
-		type: t.union([t.literal("tableHeader"), t.literal("tableCell")]),
-		content: RichTextLegacyContent,
-	}),
-	t.exact(
-		t.partial({
-			columnWidth: t.number,
+const TableCellLegacy = withKey(
+	t.intersection([
+		t.strict({
+			type: t.union([t.literal("tableHeader"), t.literal("tableCell")]),
+			content: RichTextLegacyContent,
 		}),
-	),
-])
+		t.exact(
+			t.partial({
+				columnWidth: t.number,
+			}),
+		),
+	]),
+)
 
-const TableRowLegacy = t.strict({
-	type: t.literal("tableRow"),
-	content: t.array(TableCellLegacy),
-})
+const TableRowLegacy = withKey(
+	t.strict({
+		type: t.literal("tableRow"),
+		content: t.array(TableCellLegacy),
+	}),
+)
 
 const TableLegacyContent = t.strict({
 	content: t.array(TableRowLegacy),

package/src/content/utils.ts

@@ -1,4 +1,6 @@
 import { isRight } from "fp-ts/lib/Either"
+import * as t from "io-ts"
+import { v4 as uuid, validate as validateUuid } from "uuid"
 
 import { FieldContentType, FieldType } from "./fields"
 
@@ -17,3 +19,21 @@ type WithContentType = { __TYPE__: string }
 export function hasContentType(obj: unknown): obj is WithContentType {
 	return typeof obj === "object" && obj !== null && "__TYPE__" in obj
 }
+
+const isUuid = (input: unknown): input is string =>
+	typeof input === "string" && validateUuid(input)
+
+const uuidWithFallback = new t.Type<string, string, unknown>(
+	"UUID",
+	isUuid,
+	(u, c) => {
+		if (typeof u === "undefined") return t.success(uuid())
+		if (isUuid(u)) return t.success(u)
+		return t.failure(u, c)
+	},
+	t.identity,
+)
+
+export function withKey<C extends t.Mixed>(codec: C) {
+	return t.intersection([t.strict({ key: uuidWithFallback }), codec])
+}