@btrc/contracts 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bowler Racing
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,24 @@
+# @btrc/contracts
+
+Zod schemas, inferred TypeScript types, and route definitions for the Bowler Racing BTRC API — the single source of truth shared by the API server, [`@btrc/api-server`](https://www.npmjs.com/package/@btrc/api-server), and [`@btrc/api-client`](https://www.npmjs.com/package/@btrc/api-client).
+
+```bash
+npm install @btrc/contracts
+```
+
+## What's inside
+
+- **Resource schemas** — `DriverSchema`, `SessionSchema`, `LapSchema`, `JudicialDecisionSchema`, and ~40 more, all Zod with inferred types.
+- **Envelopes** — `responseSchema(x)` / `pageSchema(x)` matching the API's `{ data, meta, links }` shape, plus `ProblemDetailsSchema` for RFC 9457 errors.
+- **Query schemas** — `PageQuerySchema`, `LapListQuerySchema`, `LeaderboardQuerySchema`, etc., with the same defaults the server applies.
+- **Route table** — `routes`: all 147 GET endpoints across 20 namespaces, each with path template, query schema, response envelope, and pagination flag. Import from `@btrc/contracts/routes` or the root.
+- `API_VERSION` — the API spec version this package was generated against.
+
+```ts
+import { routes, DriverSchema, type Driver } from '@btrc/contracts';
+
+routes.drivers.get.path; // '/drivers/{driverId}'
+const driver: Driver = DriverSchema.parse(json);
+```
+
+Most consumers want [`@btrc/api-server`](https://www.npmjs.com/package/@btrc/api-server) (Node/SSR client) or [`@btrc/api-client`](https://www.npmjs.com/package/@btrc/api-client) (browser + React hooks) instead of using this package directly.

package/dist/envelopes.d.ts

@@ -0,0 +1,205 @@
+import { z } from 'zod';
+export declare const ProblemDetailsSchema: z.ZodObject<{
+    type: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodNumber;
+    detail: z.ZodString;
+    instance: z.ZodString;
+    requestId: z.ZodString;
+    errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        message: string;
+    }, {
+        path: string;
+        message: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    title: string;
+    status: number;
+    detail: string;
+    instance: string;
+    requestId: string;
+    errors?: {
+        path: string;
+        message: string;
+    }[] | undefined;
+}, {
+    type: string;
+    title: string;
+    status: number;
+    detail: string;
+    instance: string;
+    requestId: string;
+    errors?: {
+        path: string;
+        message: string;
+    }[] | undefined;
+}>;
+export type ProblemDetails = z.infer<typeof ProblemDetailsSchema>;
+export declare const PageMetaSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    asOf: z.ZodString;
+    hasMore: z.ZodBoolean;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    requestId: string;
+    asOf: string;
+    hasMore: boolean;
+    nextCursor: string | null;
+}, {
+    requestId: string;
+    asOf: string;
+    hasMore: boolean;
+    nextCursor: string | null;
+}>;
+export declare const LinksSchema: z.ZodObject<{
+    self: z.ZodString;
+    next: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    self: string;
+    next?: string | null | undefined;
+}, {
+    self: string;
+    next?: string | null | undefined;
+}>;
+export declare function responseSchema<T extends z.ZodTypeAny>(data: T): z.ZodObject<{
+    data: T;
+    meta: z.ZodObject<{
+        requestId: z.ZodString;
+        asOf: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        requestId: string;
+        asOf: string;
+    }, {
+        requestId: string;
+        asOf: string;
+    }>;
+    links: z.ZodObject<{
+        self: z.ZodString;
+        next: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        self: string;
+        next?: string | null | undefined;
+    }, {
+        self: string;
+        next?: string | null | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    data: T;
+    meta: z.ZodObject<{
+        requestId: z.ZodString;
+        asOf: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        requestId: string;
+        asOf: string;
+    }, {
+        requestId: string;
+        asOf: string;
+    }>;
+    links: z.ZodObject<{
+        self: z.ZodString;
+        next: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        self: string;
+        next?: string | null | undefined;
+    }, {
+        self: string;
+        next?: string | null | undefined;
+    }>;
+}>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.baseObjectInputType<{
+    data: T;
+    meta: z.ZodObject<{
+        requestId: z.ZodString;
+        asOf: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        requestId: string;
+        asOf: string;
+    }, {
+        requestId: string;
+        asOf: string;
+    }>;
+    links: z.ZodObject<{
+        self: z.ZodString;
+        next: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        self: string;
+        next?: string | null | undefined;
+    }, {
+        self: string;
+        next?: string | null | undefined;
+    }>;
+}> extends infer T_2 ? { [k in keyof T_2]: T_2[k]; } : never>;
+export declare function pageSchema<T extends z.ZodTypeAny>(item: T): z.ZodObject<{
+    data: z.ZodArray<T, "many">;
+    meta: z.ZodObject<{
+        requestId: z.ZodString;
+        asOf: z.ZodString;
+        hasMore: z.ZodBoolean;
+        nextCursor: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        requestId: string;
+        asOf: string;
+        hasMore: boolean;
+        nextCursor: string | null;
+    }, {
+        requestId: string;
+        asOf: string;
+        hasMore: boolean;
+        nextCursor: string | null;
+    }>;
+    links: z.ZodObject<{
+        self: z.ZodString;
+        next: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        self: string;
+        next?: string | null | undefined;
+    }, {
+        self: string;
+        next?: string | null | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    data: T["_output"][];
+    meta: {
+        requestId: string;
+        asOf: string;
+        hasMore: boolean;
+        nextCursor: string | null;
+    };
+    links: {
+        self: string;
+        next?: string | null | undefined;
+    };
+}, {
+    data: T["_input"][];
+    meta: {
+        requestId: string;
+        asOf: string;
+        hasMore: boolean;
+        nextCursor: string | null;
+    };
+    links: {
+        self: string;
+        next?: string | null | undefined;
+    };
+}>;
+export type ApiResponse<T> = {
+    data: T;
+    meta: {
+        requestId: string;
+        asOf: string;
+    };
+    links: {
+        self: string;
+        next?: string | null;
+    };
+};
+export type CursorPage<T> = {
+    data: T[];
+    meta: z.infer<typeof PageMetaSchema>;
+    links: z.infer<typeof LinksSchema>;
+};
+//# sourceMappingURL=envelopes.d.ts.map

package/dist/envelopes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelopes.d.ts","sourceRoot":"","sources":["../src/envelopes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;EAKzB,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;EAGtB,CAAC;AAEH,wBAAgB,cAAc,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,IAAI,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAM7D;AAED,wBAAgB,UAAU,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,IAAI,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAMzD;AAED,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;IAC3B,IAAI,EAAE,CAAC,CAAC;IACR,IAAI,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1C,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;CAC/C,CAAC;AAEF,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAC1B,IAAI,EAAE,CAAC,EAAE,CAAC;IACV,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;IACrC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;CACpC,CAAC"}

package/dist/envelopes.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { IsoDateTime } from './primitives.js';
+export const ProblemDetailsSchema = z.object({
+    type: z.string().url(),
+    title: z.string(),
+    status: z.number().int().min(400).max(599),
+    detail: z.string(),
+    instance: z.string(),
+    requestId: z.string(),
+    errors: z.array(z.object({ path: z.string(), message: z.string() })).optional(),
+});
+export const PageMetaSchema = z.object({
+    requestId: z.string(),
+    asOf: IsoDateTime,
+    hasMore: z.boolean(),
+    nextCursor: z.string().nullable(),
+});
+export const LinksSchema = z.object({
+    self: z.string(),
+    next: z.string().nullable().optional(),
+});
+export function responseSchema(data) {
+    return z.object({
+        data,
+        meta: z.object({ requestId: z.string(), asOf: IsoDateTime }),
+        links: LinksSchema,
+    });
+}
+export function pageSchema(item) {
+    return z.object({
+        data: z.array(item),
+        meta: PageMetaSchema,
+        links: LinksSchema,
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './version.js';
+export * from './primitives.js';
+export * from './envelopes.js';
+export * from './resources.js';
+export * from './queries.js';
+export * from './routes.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from './version.js';
+export * from './primitives.js';
+export * from './envelopes.js';
+export * from './resources.js';
+export * from './queries.js';
+export * from './routes.js';

package/dist/primitives.d.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+export declare const Id: z.ZodString;
+export declare const Uuid: z.ZodString;
+export declare const IsoDate: z.ZodString;
+export declare const IsoDateTime: z.ZodString;
+export declare const NullableText: z.ZodNullable<z.ZodString>;
+export declare const NullableNumber: z.ZodNullable<z.ZodNumber>;
+export declare const QueryBoolean: z.ZodEffects<z.ZodBoolean, boolean, unknown>;
+export declare const PublicJsonValue: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+export declare const PublicJson: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+export declare const ChampionshipId: z.ZodBranded<z.ZodString, "ChampionshipId">;
+export declare const CircuitId: z.ZodBranded<z.ZodString, "CircuitId">;
+export declare const CircuitLayoutId: z.ZodBranded<z.ZodString, "CircuitLayoutId">;
+export declare const EventId: z.ZodBranded<z.ZodString, "EventId">;
+export declare const SessionId: z.ZodBranded<z.ZodString, "SessionId">;
+export declare const DriverId: z.ZodBranded<z.ZodString, "DriverId">;
+export declare const EntryId: z.ZodBranded<z.ZodString, "EntryId">;
+export declare const TeamId: z.ZodBranded<z.ZodString, "TeamId">;
+export declare const VehicleId: z.ZodBranded<z.ZodString, "VehicleId">;
+export declare const LapId: z.ZodBranded<z.ZodString, "LapId">;
+export declare const SourceDocumentId: z.ZodBranded<z.ZodString, "SourceDocumentId">;
+export declare const SourcePageId: z.ZodBranded<z.ZodString, "SourcePageId">;
+export declare const NoticeboardSnapshotId: z.ZodBranded<z.ZodString, "NoticeboardSnapshotId">;
+export declare const NoticeboardDocumentId: z.ZodBranded<z.ZodString, "NoticeboardDocumentId">;
+export declare const EventPermitId: z.ZodBranded<z.ZodString, "EventPermitId">;
+export declare const OfficialId: z.ZodBranded<z.ZodString, "OfficialId">;
+export declare const BulletinId: z.ZodBranded<z.ZodString, "BulletinId">;
+export declare const BulletinActionId: z.ZodBranded<z.ZodString, "BulletinActionId">;
+export declare const SessionPublicationId: z.ZodBranded<z.ZodString, "SessionPublicationId">;
+export declare const JudicialDecisionId: z.ZodBranded<z.ZodString, "JudicialDecisionId">;
+export declare const SanctionId: z.ZodBranded<z.ZodString, "SanctionId">;
+export type ChampionshipId = z.infer<typeof ChampionshipId>;
+export type CircuitId = z.infer<typeof CircuitId>;
+export type CircuitLayoutId = z.infer<typeof CircuitLayoutId>;
+export type EventId = z.infer<typeof EventId>;
+export type SessionId = z.infer<typeof SessionId>;
+export type DriverId = z.infer<typeof DriverId>;
+export type EntryId = z.infer<typeof EntryId>;
+export type TeamId = z.infer<typeof TeamId>;
+export type VehicleId = z.infer<typeof VehicleId>;
+export type LapId = z.infer<typeof LapId>;
+export declare const PublicationVersionSchema: z.ZodString;
+export declare const QualityStatusSchema: z.ZodEnum<["unchecked", "verified", "exception", "not_applicable", "provisional"]>;
+export declare const ProvenanceSchema: z.ZodObject<{
+    sourcePageId: z.ZodNullable<z.ZodBranded<z.ZodString, "SourcePageId">>;
+    sourceDocumentId: z.ZodOptional<z.ZodNullable<z.ZodBranded<z.ZodString, "SourceDocumentId">>>;
+    kind: z.ZodOptional<z.ZodEnum<["published", "derived"]>>;
+}, "strip", z.ZodTypeAny, {
+    sourcePageId: (string & z.BRAND<"SourcePageId">) | null;
+    sourceDocumentId?: (string & z.BRAND<"SourceDocumentId">) | null | undefined;
+    kind?: "derived" | "published" | undefined;
+}, {
+    sourcePageId: string | null;
+    sourceDocumentId?: string | null | undefined;
+    kind?: "derived" | "published" | undefined;
+}>;
+export declare const QualitySchema: z.ZodObject<{
+    status: z.ZodEnum<["unchecked", "verified", "exception", "not_applicable", "provisional"]>;
+    checkedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    pipelineVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    status: "exception" | "not_applicable" | "provisional" | "unchecked" | "verified";
+    checkedAt?: string | null | undefined;
+    pipelineVersion?: string | null | undefined;
+}, {
+    status: "exception" | "not_applicable" | "provisional" | "unchecked" | "verified";
+    checkedAt?: string | null | undefined;
+    pipelineVersion?: string | null | undefined;
+}>;
+//# sourceMappingURL=primitives.d.ts.map

package/dist/primitives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.d.ts","sourceRoot":"","sources":["../src/primitives.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,EAAE,aAAoB,CAAC;AACpC,eAAO,MAAM,IAAI,aAAoB,CAAC;AACtC,eAAO,MAAM,OAAO,aAA0C,CAAC;AAC/D,eAAO,MAAM,WAAW,aAAwC,CAAC;AACjE,eAAO,MAAM,YAAY,4BAAwB,CAAC;AAClD,eAAO,MAAM,cAAc,4BAAwB,CAAC;AACpD,eAAO,MAAM,YAAY,8CAKV,CAAC;AAEhB,eAAO,MAAM,eAAe,iEAA2D,CAAC;AACxF,eAAO,MAAM,UAAU,0GAAuC,CAAC;AAE/D,eAAO,MAAM,cAAc,6CAA+B,CAAC;AAC3D,eAAO,MAAM,SAAS,wCAA0B,CAAC;AACjD,eAAO,MAAM,eAAe,8CAAgC,CAAC;AAC7D,eAAO,MAAM,OAAO,sCAA0B,CAAC;AAC/C,eAAO,MAAM,SAAS,wCAA4B,CAAC;AACnD,eAAO,MAAM,QAAQ,uCAA2B,CAAC;AACjD,eAAO,MAAM,OAAO,sCAA0B,CAAC;AAC/C,eAAO,MAAM,MAAM,qCAAuB,CAAC;AAC3C,eAAO,MAAM,SAAS,wCAA0B,CAAC;AACjD,eAAO,MAAM,KAAK,oCAAsB,CAAC;AACzC,eAAO,MAAM,gBAAgB,+CAAmC,CAAC;AACjE,eAAO,MAAM,YAAY,2CAA+B,CAAC;AACzD,eAAO,MAAM,qBAAqB,oDAAwC,CAAC;AAC3E,eAAO,MAAM,qBAAqB,oDAAwC,CAAC;AAC3E,eAAO,MAAM,aAAa,4CAAgC,CAAC;AAC3D,eAAO,MAAM,UAAU,yCAA6B,CAAC;AACrD,eAAO,MAAM,UAAU,yCAA6B,CAAC;AACrD,eAAO,MAAM,gBAAgB,+CAAmC,CAAC;AACjE,eAAO,MAAM,oBAAoB,mDAAuC,CAAC;AACzE,eAAO,MAAM,kBAAkB,iDAAqC,CAAC;AACrE,eAAO,MAAM,UAAU,yCAA6B,CAAC;AAErD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAC5D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAClD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC9D,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAC;AAC9C,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAClD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAChD,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAC;AAC9C,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAC5C,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAClD,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,CAAC;AAE1C,eAAO,MAAM,wBAAwB,aAA6B,CAAC;AACnE,eAAO,MAAM,mBAAmB,oFAM9B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAI3B,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;EAIxB,CAAC"}

package/dist/primitives.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+export const Id = z.string().min(1);
+export const Uuid = z.string().uuid();
+export const IsoDate = z.string().regex(/^\d{4}-\d{2}-\d{2}$/);
+export const IsoDateTime = z.string().datetime({ offset: true });
+export const NullableText = z.string().nullable();
+export const NullableNumber = z.number().nullable();
+export const QueryBoolean = z.preprocess((value) => {
+    if (typeof value !== 'string')
+        return value;
+    if (value === 'true' || value === '1')
+        return true;
+    if (value === 'false' || value === '0')
+        return false;
+    return value;
+}, z.boolean());
+export const PublicJsonValue = z.union([z.string(), z.number(), z.boolean(), z.null()]);
+export const PublicJson = z.record(PublicJsonValue).nullable();
+export const ChampionshipId = Id.brand();
+export const CircuitId = Id.brand();
+export const CircuitLayoutId = Id.brand();
+export const EventId = Uuid.brand();
+export const SessionId = Uuid.brand();
+export const DriverId = Uuid.brand();
+export const EntryId = Uuid.brand();
+export const TeamId = Id.brand();
+export const VehicleId = Id.brand();
+export const LapId = Id.brand();
+export const SourceDocumentId = Uuid.brand();
+export const SourcePageId = Uuid.brand();
+export const NoticeboardSnapshotId = Uuid.brand();
+export const NoticeboardDocumentId = Uuid.brand();
+export const EventPermitId = Uuid.brand();
+export const OfficialId = Uuid.brand();
+export const BulletinId = Uuid.brand();
+export const BulletinActionId = Uuid.brand();
+export const SessionPublicationId = Uuid.brand();
+export const JudicialDecisionId = Uuid.brand();
+export const SanctionId = Uuid.brand();
+export const PublicationVersionSchema = z.string().min(1).max(120);
+export const QualityStatusSchema = z.enum([
+    'unchecked',
+    'verified',
+    'exception',
+    'not_applicable',
+    'provisional',
+]);
+export const ProvenanceSchema = z.object({
+    sourcePageId: SourcePageId.nullable(),
+    sourceDocumentId: SourceDocumentId.nullable().optional(),
+    kind: z.enum(['published', 'derived']).optional(),
+});
+export const QualitySchema = z.object({
+    status: QualityStatusSchema,
+    checkedAt: IsoDateTime.nullable().optional(),
+    pipelineVersion: NullableText.optional(),
+});