@openframe-org/criteria-set-protocol 1.5.20 → 2.0.0-beta.10

package/README.md

@@ -27,12 +27,12 @@ The library contains the types defined in the protocol v1 specification, and a s
 | -------------------------- | --------------------------------------------------- |
 | **Metadata types**         |                                                     |
 | `Metadata`                 |                                                     |
-| `Quality`                  |                                                     |
-| `QualityStyle`             |                                                     |
+| `Theme`                    |                                                     |
+| `ThemeStyle`               |                                                     |
 | `Color`                    |                                                     |
 | **Task tree types**        |                                                     |
 | `CriteriaTree`             |                                                     |
-| `Quality`                  |                                                     |
+| `Theme`                    |                                                     |
 | `Criterion`                |                                                     |
 | `TaskGroup`                |                                                     |
 | `Task`                     |                                                     |

package/dist/services/i-versioned.service.d.ts

@@ -0,0 +1,16 @@
+import { ProtocolVersionServiceMap } from '../types';
+/**
+ * Interface for versioned services
+ *
+ * Services that implement this interface can be managed by the VersionsService
+ */
+export interface IVersionedService {
+    /**
+     * The SemVer version of the service
+     */
+    version: string;
+    /**
+     * Whether the service supports the given protocol version
+     */
+    supportsProtocol: <ProtocolVersion extends number>(protocolVersion: ProtocolVersion) => this is ProtocolVersionServiceMap<ProtocolVersion>;
+}

package/dist/services/i-versioned.service.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from './i-versioned.service';
+export * from './versions.service';

package/dist/services/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./i-versioned.service"), exports);
+__exportStar(require("./versions.service"), exports);

package/dist/services/versions.service.d.ts

@@ -0,0 +1,38 @@
+import { IVersionedService } from './i-versioned.service';
+import { ProtocolVersionServiceMap } from '../types';
+/**
+ * Service for managing versions of services
+ *
+ * The VersionsService class is a utility class for services which implement different versions of the protocol, and different versions of their
+ * own service. For example, say you have a v1service, v11service, v2service and v21service with versions 1.0, 1.1, 2.0 and 2.1 respectively.
+ * The VersionsService class can be used to manage these services:
+ *
+ * const versionsService = new VersionsService([v1service, v11service, v2service, v21service]);
+ * versionsService.getLatestVersion(); // v21service
+ * versionsService.getServiceVersions(1); // [v1service, v11service]
+ * versionsService.getServiceVersions(2); // [v2service, v21service]
+ * versionsService.get('1.1'); // v11service
+ */
+export declare class VersionsService {
+    protected versions: IVersionedService[];
+    /**
+     * @param versions An array of services implementing IVersionedService
+     */
+    constructor(versions: IVersionedService[]);
+    /**
+     * Get all services
+     */
+    getAll(): IVersionedService[];
+    /**
+     * Retrieve the services which are compatible with the requested protocol version
+     */
+    getServiceVersions<ProtocolVersion extends number, ProtocolImplementingService = ProtocolVersionServiceMap<ProtocolVersion>>(protocolVersion: ProtocolVersion): ProtocolImplementingService[];
+    /**
+     * Retrieve a service by version
+     */
+    get(version: string): IVersionedService | undefined;
+    /**
+     * Retrieve the latest service
+     */
+    getLatestVersion(): IVersionedService;
+}

package/dist/services/versions.service.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionsService = void 0;
+/**
+ * Service for managing versions of services
+ *
+ * The VersionsService class is a utility class for services which implement different versions of the protocol, and different versions of their
+ * own service. For example, say you have a v1service, v11service, v2service and v21service with versions 1.0, 1.1, 2.0 and 2.1 respectively.
+ * The VersionsService class can be used to manage these services:
+ *
+ * const versionsService = new VersionsService([v1service, v11service, v2service, v21service]);
+ * versionsService.getLatestVersion(); // v21service
+ * versionsService.getServiceVersions(1); // [v1service, v11service]
+ * versionsService.getServiceVersions(2); // [v2service, v21service]
+ * versionsService.get('1.1'); // v11service
+ */
+class VersionsService {
+    /**
+     * @param versions An array of services implementing IVersionedService
+     */
+    constructor(versions) {
+        this.versions = versions;
+    }
+    /**
+     * Get all services
+     */
+    getAll() {
+        return this.versions;
+    }
+    /**
+     * Retrieve the services which are compatible with the requested protocol version
+     */
+    getServiceVersions(protocolVersion) {
+        return this.versions.filter((service) => service.supportsProtocol(protocolVersion));
+    }
+    /**
+     * Retrieve a service by version
+     */
+    get(version) {
+        return this.versions.find((service) => service.version === version);
+    }
+    /**
+     * Retrieve the latest service
+     */
+    getLatestVersion() {
+        return this.versions[this.versions.length - 1];
+    }
+}
+exports.VersionsService = VersionsService;

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+import { IProtocolV1Service } from './v1/services/i-protocol-v1.service';
+export type ProtocolVersionServiceMap<Version extends number> = Version extends 1 ? IProtocolV1Service : unknown;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/v1/schemas/certification.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-export declare const certificationDefinitionTypeSchema: z.ZodUnion<[z.ZodLiteral<"number">, z.ZodLiteral<"percentage">]>;
+export declare const certificationDefinitionTypeSchema: z.ZodEnum<["number", "percentage"]>;
 export declare const numberBasedCertificationDefinitionRulesSchema: z.ZodObject<{
     minimum: z.ZodOptional<z.ZodNumber>;
     exclusiveMinimum: z.ZodOptional<z.ZodNumber>;
@@ -32,38 +32,12 @@ export declare const percentageBasedCertificationDefinitionRulesSchema: z.ZodObj
     exclusiveMinimum?: number | undefined;
     exclusiveMaximum?: number | undefined;
 }>;
-export declare const abstractCertificationDefinitionSchema: z.ZodObject<{
-    code: z.ZodString;
-    type: z.ZodUnion<[z.ZodLiteral<"number">, z.ZodLiteral<"percentage">]>;
-    icon: z.ZodOptional<z.ZodString>;
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    rules: z.ZodAny;
-    rulesText: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    code: string;
-    name: string;
-    type: "number" | "percentage";
-    rulesText: string;
-    description?: string | undefined;
-    icon?: string | undefined;
-    rules?: any;
-}, {
-    code: string;
-    name: string;
-    type: "number" | "percentage";
-    rulesText: string;
-    description?: string | undefined;
-    icon?: string | undefined;
-    rules?: any;
-}>;
 export declare const numberBasedCertificationDefinitionSchema: z.ZodObject<z.objectUtil.extendShape<{
+    type: z.ZodEnum<["number", "percentage"]>;
     code: z.ZodString;
-    type: z.ZodUnion<[z.ZodLiteral<"number">, z.ZodLiteral<"percentage">]>;
     icon: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
-    rules: z.ZodAny;
     rulesText: z.ZodString;
 }, {
     type: z.ZodLiteral<"number">;
@@ -84,39 +58,38 @@ export declare const numberBasedCertificationDefinitionSchema: z.ZodObject<z.obj
         exclusiveMaximum?: number | undefined;
     }>;
 }>, "strip", z.ZodTypeAny, {
+    type: "number";
     code: string;
     name: string;
-    type: "number";
+    rulesText: string;
     rules: {
         minimum?: number | undefined;
         maximum?: number | undefined;
         exclusiveMinimum?: number | undefined;
         exclusiveMaximum?: number | undefined;
     };
-    rulesText: string;
     description?: string | undefined;
     icon?: string | undefined;
 }, {
+    type: "number";
     code: string;
     name: string;
-    type: "number";
+    rulesText: string;
     rules: {
         minimum?: number | undefined;
         maximum?: number | undefined;
         exclusiveMinimum?: number | undefined;
         exclusiveMaximum?: number | undefined;
     };
-    rulesText: string;
     description?: string | undefined;
     icon?: string | undefined;
 }>;
 export declare const percentageBasedCertificationDefinitionSchema: z.ZodObject<z.objectUtil.extendShape<{
+    type: z.ZodEnum<["number", "percentage"]>;
     code: z.ZodString;
-    type: z.ZodUnion<[z.ZodLiteral<"number">, z.ZodLiteral<"percentage">]>;
     icon: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
-    rules: z.ZodAny;
     rulesText: z.ZodString;
 }, {
     type: z.ZodLiteral<"percentage">;
@@ -137,39 +110,38 @@ export declare const percentageBasedCertificationDefinitionSchema: z.ZodObject<z
         exclusiveMaximum?: number | undefined;
     }>;
 }>, "strip", z.ZodTypeAny, {
+    type: "percentage";
     code: string;
     name: string;
-    type: "percentage";
+    rulesText: string;
     rules: {
         minimum?: number | undefined;
         maximum?: number | undefined;
         exclusiveMinimum?: number | undefined;
         exclusiveMaximum?: number | undefined;
     };
-    rulesText: string;
     description?: string | undefined;
     icon?: string | undefined;
 }, {
+    type: "percentage";
     code: string;
     name: string;
-    type: "percentage";
+    rulesText: string;
     rules: {
         minimum?: number | undefined;
         maximum?: number | undefined;
         exclusiveMinimum?: number | undefined;
         exclusiveMaximum?: number | undefined;
     };
-    rulesText: string;
     description?: string | undefined;
     icon?: string | undefined;
 }>;
 export declare const certificationDefinitionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<z.objectUtil.extendShape<{
+    type: z.ZodEnum<["number", "percentage"]>;
     code: z.ZodString;
-    type: z.ZodUnion<[z.ZodLiteral<"number">, z.ZodLiteral<"percentage">]>;
     icon: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
-    rules: z.ZodAny;
     rulesText: z.ZodString;
 }, {
     type: z.ZodLiteral<"number">;
@@ -190,38 +162,37 @@ export declare const certificationDefinitionSchema: z.ZodDiscriminatedUnion<"typ
         exclusiveMaximum?: number | undefined;
     }>;
 }>, "strip", z.ZodTypeAny, {
+    type: "number";
     code: string;
     name: string;
-    type: "number";
+    rulesText: string;
     rules: {
         minimum?: number | undefined;
         maximum?: number | undefined;
         exclusiveMinimum?: number | undefined;
         exclusiveMaximum?: number | undefined;
     };
-    rulesText: string;
     description?: string | undefined;
     icon?: string | undefined;
 }, {
+    type: "number";
     code: string;
     name: string;
-    type: "number";
+    rulesText: string;
     rules: {
         minimum?: number | undefined;
         maximum?: number | undefined;
         exclusiveMinimum?: number | undefined;
         exclusiveMaximum?: number | undefined;
     };
-    rulesText: string;
     description?: string | undefined;
     icon?: string | undefined;
 }>, z.ZodObject<z.objectUtil.extendShape<{
+    type: z.ZodEnum<["number", "percentage"]>;
     code: z.ZodString;
-    type: z.ZodUnion<[z.ZodLiteral<"number">, z.ZodLiteral<"percentage">]>;
     icon: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
-    rules: z.ZodAny;
     rulesText: z.ZodString;
 }, {
     type: z.ZodLiteral<"percentage">;
@@ -242,29 +213,29 @@ export declare const certificationDefinitionSchema: z.ZodDiscriminatedUnion<"typ
         exclusiveMaximum?: number | undefined;
     }>;
 }>, "strip", z.ZodTypeAny, {
+    type: "percentage";
     code: string;
     name: string;
-    type: "percentage";
+    rulesText: string;
     rules: {
         minimum?: number | undefined;
         maximum?: number | undefined;
         exclusiveMinimum?: number | undefined;
         exclusiveMaximum?: number | undefined;
     };
-    rulesText: string;
     description?: string | undefined;
     icon?: string | undefined;
 }, {
+    type: "percentage";
     code: string;
     name: string;
-    type: "percentage";
+    rulesText: string;
     rules: {
         minimum?: number | undefined;
         maximum?: number | undefined;
         exclusiveMinimum?: number | undefined;
         exclusiveMaximum?: number | undefined;
     };
-    rulesText: string;
     description?: string | undefined;
     icon?: string | undefined;
 }>]>;

package/dist/v1/schemas/certification.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.certificationDefinitionSchema = exports.percentageBasedCertificationDefinitionSchema = exports.numberBasedCertificationDefinitionSchema = exports.abstractCertificationDefinitionSchema = exports.percentageBasedCertificationDefinitionRulesSchema = exports.numberBasedCertificationDefinitionRulesSchema = exports.certificationDefinitionTypeSchema = void 0;
+exports.certificationDefinitionSchema = exports.percentageBasedCertificationDefinitionSchema = exports.numberBasedCertificationDefinitionSchema = exports.percentageBasedCertificationDefinitionRulesSchema = exports.numberBasedCertificationDefinitionRulesSchema = exports.certificationDefinitionTypeSchema = void 0;
 const zod_1 = require("zod");
-exports.certificationDefinitionTypeSchema = zod_1.z.union([
-    zod_1.z.literal("number"),
-    zod_1.z.literal("percentage"),
+exports.certificationDefinitionTypeSchema = zod_1.z.enum([
+    "number",
+    "percentage",
 ]);
 exports.numberBasedCertificationDefinitionRulesSchema = zod_1.z.object({
     minimum: zod_1.z.number().optional(),
@@ -13,20 +13,19 @@ exports.numberBasedCertificationDefinitionRulesSchema = zod_1.z.object({
     exclusiveMaximum: zod_1.z.number().optional(),
 });
 exports.percentageBasedCertificationDefinitionRulesSchema = exports.numberBasedCertificationDefinitionRulesSchema;
-exports.abstractCertificationDefinitionSchema = zod_1.z.object({
-    code: zod_1.z.string(),
+const abstractCertificationDefinitionSchema = zod_1.z.object({
     type: exports.certificationDefinitionTypeSchema,
+    code: zod_1.z.string(),
     icon: zod_1.z.string().optional(),
     name: zod_1.z.string(),
     description: zod_1.z.string().optional(),
-    rules: zod_1.z.any(),
     rulesText: zod_1.z.string(),
 });
-exports.numberBasedCertificationDefinitionSchema = exports.abstractCertificationDefinitionSchema.extend({
+exports.numberBasedCertificationDefinitionSchema = abstractCertificationDefinitionSchema.extend({
     type: zod_1.z.literal("number"),
     rules: exports.numberBasedCertificationDefinitionRulesSchema,
 });
-exports.percentageBasedCertificationDefinitionSchema = exports.abstractCertificationDefinitionSchema.extend({
+exports.percentageBasedCertificationDefinitionSchema = abstractCertificationDefinitionSchema.extend({
     type: zod_1.z.literal("percentage"),
     rules: exports.percentageBasedCertificationDefinitionRulesSchema,
 });

package/dist/v1/schemas/common.d.ts

@@ -0,0 +1,143 @@
+import { z } from "zod";
+export declare const colorSchema: z.ZodUnion<[z.ZodString, z.ZodObject<{
+    red: z.ZodNumber;
+    green: z.ZodNumber;
+    blue: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    red: number;
+    green: number;
+    blue: number;
+}, {
+    red: number;
+    green: number;
+    blue: number;
+}>]>;
+export declare const taskItemScalarValueSchema: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+export declare const taskItemValueSchema: z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, "many">]>;
+export declare const elementDataSchema: z.ZodObject<{
+    value: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, "many">]>>;
+    text: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    value?: string | number | boolean | (string | number | boolean | null)[] | null | undefined;
+    text?: string | undefined;
+}, {
+    value?: string | number | boolean | (string | number | boolean | null)[] | null | undefined;
+    text?: string | undefined;
+}>;
+export declare const criteriaTreeElementTypeSchema: z.ZodEnum<["theme", "criterion", "task-group", "task", "task-item"]>;
+export declare const abstractElementSchema: z.ZodObject<{
+    type: z.ZodEnum<["theme", "criterion", "task-group", "task", "task-item"]>;
+    title: z.ZodString;
+    code: z.ZodString;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    documentation: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<z.objectUtil.extendShape<{
+        type: z.ZodEnum<["pdf", "text", "link"]>;
+        label: z.ZodString;
+        text: z.ZodString;
+    }, {
+        type: z.ZodLiteral<"pdf">;
+        url: z.ZodString;
+    }>, "strip", z.ZodTypeAny, {
+        type: "pdf";
+        url: string;
+        label: string;
+        text: string;
+    }, {
+        type: "pdf";
+        url: string;
+        label: string;
+        text: string;
+    }>, z.ZodObject<z.objectUtil.extendShape<{
+        type: z.ZodEnum<["pdf", "text", "link"]>;
+        label: z.ZodString;
+        text: z.ZodString;
+    }, {
+        type: z.ZodLiteral<"text">;
+    }>, "strip", z.ZodTypeAny, {
+        type: "text";
+        label: string;
+        text: string;
+    }, {
+        type: "text";
+        label: string;
+        text: string;
+    }>, z.ZodObject<z.objectUtil.extendShape<{
+        type: z.ZodEnum<["pdf", "text", "link"]>;
+        label: z.ZodString;
+        text: z.ZodString;
+    }, {
+        type: z.ZodLiteral<"link">;
+        url: z.ZodString;
+    }>, "strip", z.ZodTypeAny, {
+        type: "link";
+        url: string;
+        label: string;
+        text: string;
+    }, {
+        type: "link";
+        url: string;
+        label: string;
+        text: string;
+    }>]>, "many">>;
+    data: z.ZodOptional<z.ZodObject<{
+        value: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, "many">]>>;
+        text: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        value?: string | number | boolean | (string | number | boolean | null)[] | null | undefined;
+        text?: string | undefined;
+    }, {
+        value?: string | number | boolean | (string | number | boolean | null)[] | null | undefined;
+        text?: string | undefined;
+    }>>;
+    sortOrder: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "theme" | "criterion" | "task-group" | "task" | "task-item";
+    code: string;
+    title: string;
+    data?: {
+        value?: string | number | boolean | (string | number | boolean | null)[] | null | undefined;
+        text?: string | undefined;
+    } | undefined;
+    tags?: string[] | undefined;
+    documentation?: ({
+        type: "pdf";
+        url: string;
+        label: string;
+        text: string;
+    } | {
+        type: "text";
+        label: string;
+        text: string;
+    } | {
+        type: "link";
+        url: string;
+        label: string;
+        text: string;
+    })[] | undefined;
+    sortOrder?: number | undefined;
+}, {
+    type: "theme" | "criterion" | "task-group" | "task" | "task-item";
+    code: string;
+    title: string;
+    data?: {
+        value?: string | number | boolean | (string | number | boolean | null)[] | null | undefined;
+        text?: string | undefined;
+    } | undefined;
+    tags?: string[] | undefined;
+    documentation?: ({
+        type: "pdf";
+        url: string;
+        label: string;
+        text: string;
+    } | {
+        type: "text";
+        label: string;
+        text: string;
+    } | {
+        type: "link";
+        url: string;
+        label: string;
+        text: string;
+    })[] | undefined;
+    sortOrder?: number | undefined;
+}>;

package/dist/v1/schemas/common.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abstractElementSchema = exports.criteriaTreeElementTypeSchema = exports.elementDataSchema = exports.taskItemValueSchema = exports.taskItemScalarValueSchema = exports.colorSchema = void 0;
+const zod_1 = require("zod");
+const documentation_1 = require("./documentation");
+exports.colorSchema = zod_1.z.union([
+    zod_1.z.string(),
+    zod_1.z.object({
+        red: zod_1.z.number(),
+        green: zod_1.z.number(),
+        blue: zod_1.z.number(),
+    }),
+]);
+// These are not "common" and are task-item specific, but generate a circular dependency if moved to task-item.ts
+exports.taskItemScalarValueSchema = zod_1.z.union([
+    zod_1.z.string(),
+    zod_1.z.number(),
+    zod_1.z.boolean(),
+    zod_1.z.null(),
+]);
+exports.taskItemValueSchema = zod_1.z.union([
+    exports.taskItemScalarValueSchema,
+    zod_1.z.array(exports.taskItemScalarValueSchema),
+]);
+exports.elementDataSchema = zod_1.z.object({
+    value: exports.taskItemValueSchema.optional(),
+    text: zod_1.z.string().optional(),
+});
+exports.criteriaTreeElementTypeSchema = zod_1.z.enum([
+    "theme",
+    "criterion",
+    "task-group",
+    "task",
+    "task-item",
+]);
+exports.abstractElementSchema = zod_1.z.object({
+    type: exports.criteriaTreeElementTypeSchema,
+    title: zod_1.z.string(),
+    code: zod_1.z.string(),
+    tags: zod_1.z.array(zod_1.z.string()).optional(),
+    documentation: zod_1.z.array(documentation_1.documentationItemSchema).optional(),
+    data: exports.elementDataSchema.optional(),
+    sortOrder: zod_1.z.number().optional(),
+});

package/dist/v1/schemas/criteria-set-id-param-schema.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+/**
+ * Validates the criteriaSetId parameter for endpoints which use it
+ */
+export declare const criteriaSetIdParamSchema: z.ZodObject<{
+    criteriaSetId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    criteriaSetId: string;
+}, {
+    criteriaSetId: string;
+}>;

package/dist/v1/schemas/criteria-set-id-param-schema.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.criteriaSetIdParamSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Validates the criteriaSetId parameter for endpoints which use it
+ */
+exports.criteriaSetIdParamSchema = zod_1.z.object({
+    criteriaSetId: zod_1.z.string()
+        .regex(/^[a-zA-Z0-9.\-_]+$/, 'Criteria set ID must contain only full stops, alphanumeric characters, dashes and underscores')
+});