@dmptool/types 1.2.6 → 2.1.0

package/README.md

@@ -7,7 +7,7 @@ This package provides Types, Zod schemas and JSON schemas to aide in integration
 The current version of the schemas can always be found in `CURRENT_SCHEMA_VERSION`. You will need to include the version is any object you create using the types in this file.
 
 Naming conventions:
-- Zod schemas do not include the word `Type` (e.g. `BooleanQuestion`, `CheckboxesAnswer`)
+- Zod schemas include the word `Schema` (e.g. `BooleanQuestionSchema`, `CheckboxesAnswerSchema`)
 - Types include the word `Type` (e.g. `BooleanQuestionType`, `CheckboxesAnswerType`)
 
 ## DMP Template Support

package/dist/answers/__tests__/defaults.spec.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const questions_1 = require("../../questions");
+const index_1 = require("../index");
+describe('Get question answer defaultJSON', () => {
+    it('returns the expected default affiliationSearch', () => {
+        const expected = {
+            type: "affiliationSearch",
+            answer: {
+                affiliationId: "",
+                affiliationName: "",
+            },
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultAffiliationSearchAnswer).toEqual(expected);
+    });
+    it('returns the expected default boolean', () => {
+        const expected = {
+            type: "boolean",
+            answer: false,
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultBooleanAnswer).toEqual(expected);
+    });
+    it('returns the expected default checkBoxes', () => {
+        const expected = {
+            type: "checkBoxes",
+            answer: [],
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultCheckboxesAnswer).toEqual(expected);
+    });
+    it('returns the expected default currency', () => {
+        const expected = {
+            type: "currency",
+            answer: 0,
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultCurrencyAnswer).toEqual(expected);
+    });
+    it('returns the expected default date', () => {
+        const expected = {
+            type: "date",
+            answer: "",
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultDateAnswer).toEqual(expected);
+    });
+    it('returns the expected default dateRange', () => {
+        const expected = {
+            type: "dateRange",
+            answer: {
+                start: "",
+                end: "",
+            },
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultDateRangeAnswer).toEqual(expected);
+    });
+    it('returns the expected default email', () => {
+        const expected = {
+            type: "email",
+            answer: "",
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultEmailAnswer).toEqual(expected);
+    });
+    it('returns the expected default licenseSearch', () => {
+        const expected = {
+            type: "licenseSearch",
+            answer: [{
+                    licenseId: "",
+                    licenseName: "",
+                }],
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultLicenseSearchAnswer).toEqual(expected);
+    });
+    it('returns the expected default metadataStandardSearch', () => {
+        const expected = {
+            type: "metadataStandardSearch",
+            answer: [{
+                    metadataStandardId: "",
+                    metadataStandardName: "",
+                }],
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultMetadataStandardSearchAnswer).toEqual(expected);
+    });
+    it('returns the expected default multiselectBox', () => {
+        const expected = {
+            type: "multiselectBox",
+            answer: [],
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultMultiselectBoxAnswer).toEqual(expected);
+    });
+    it('returns the expected default number', () => {
+        const expected = {
+            type: "number",
+            answer: 0,
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultNumberAnswer).toEqual(expected);
+    });
+    it('returns the expected default numberRange', () => {
+        const expected = {
+            type: "numberRange",
+            answer: {
+                start: 0,
+                end: 0,
+            },
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultNumberRangeAnswer).toEqual(expected);
+    });
+    it('returns the expected default numberWithContext', () => {
+        const expected = {
+            type: "numberWithContext",
+            answer: {
+                value: 0,
+                context: "",
+            },
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultNumberWithContextAnswer).toEqual(expected);
+    });
+    it('returns the expected default radioButtons', () => {
+        const expected = {
+            type: "radioButtons",
+            answer: "",
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultRadioButtonsAnswer).toEqual(expected);
+    });
+    it('returns the expected default repositorySearch', () => {
+        const expected = {
+            type: "repositorySearch",
+            answer: [{
+                    repositoryId: "",
+                    repositoryName: "",
+                }],
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultRepositorySearchAnswer).toEqual(expected);
+    });
+    it('returns the expected default researchOutputTable', () => {
+        const expected = {
+            type: "researchOutputTable",
+            columnHeadings: ["Title", "Type"],
+            answer: [{
+                    columns: [
+                        {
+                            type: "text",
+                            answer: "",
+                            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+                        },
+                        {
+                            type: "selectBox",
+                            answer: "",
+                            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+                        }
+                    ]
+                }],
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultResearchOutputTableAnswer).toEqual(expected);
+    });
+    it('returns the expected default selectBox', () => {
+        const expected = {
+            type: "selectBox",
+            answer: "",
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultSelectBoxAnswer).toEqual(expected);
+    });
+    it('returns the expected default table', () => {
+        const expected = {
+            type: "table",
+            columnHeadings: ["Column A"],
+            answer: [{
+                    columns: [{
+                            type: "textArea",
+                            answer: "",
+                            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+                        }]
+                }],
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultTableAnswer).toEqual(expected);
+    });
+    it('returns the expected default text', () => {
+        const expected = {
+            type: "text",
+            answer: "",
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultTextAnswer).toEqual(expected);
+    });
+    it('returns the expected default textArea', () => {
+        const expected = {
+            type: "textArea",
+            answer: "",
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultTextAreaAnswer).toEqual(expected);
+    });
+    it('returns the expected default url', () => {
+        const expected = {
+            type: "url",
+            answer: "",
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(index_1.DefaultURLAnswer).toEqual(expected);
+    });
+});

package/dist/answers/answer.d.ts

@@ -1,22 +1,37 @@
 import { z } from 'zod';
 export declare const AnswerSchema: z.ZodObject<{
-    type: z.ZodEnum<["affiliationSearch", "boolean", "checkBoxes", "currency", "date", "dateRange", "email", "licenseSearch", "metadataStandardSearch", "multiselectBox", "number", "numberRange", "numberWithContext", "radioButtons", "repositorySearch", "researchOutputTable", "selectBox", "table", "text", "textArea", "url"]>;
-    meta: z.ZodDefault<z.ZodObject<{
+    type: z.ZodEnum<{
+        number: "number";
+        boolean: "boolean";
+        affiliationSearch: "affiliationSearch";
+        checkBoxes: "checkBoxes";
+        currency: "currency";
+        date: "date";
+        dateRange: "dateRange";
+        email: "email";
+        licenseSearch: "licenseSearch";
+        metadataStandardSearch: "metadataStandardSearch";
+        multiselectBox: "multiselectBox";
+        numberRange: "numberRange";
+        numberWithContext: "numberWithContext";
+        radioButtons: "radioButtons";
+        repositorySearch: "repositorySearch";
+        researchOutputTable: "researchOutputTable";
+        selectBox: "selectBox";
+        table: "table";
+        text: "text";
+        textArea: "textArea";
+        url: "url";
+    }>;
+    meta: z.ZodObject<{
         schemaVersion: z.ZodDefault<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        schemaVersion: string;
-    }, {
-        schemaVersion?: string | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const DefaultAnswer: {
     type: "number" | "boolean" | "affiliationSearch" | "checkBoxes" | "currency" | "date" | "dateRange" | "email" | "licenseSearch" | "metadataStandardSearch" | "multiselectBox" | "numberRange" | "numberWithContext" | "radioButtons" | "repositorySearch" | "researchOutputTable" | "selectBox" | "table" | "text" | "textArea" | "url";
     meta: {
         schemaVersion: string;
     };
-}, {
-    type: "number" | "boolean" | "affiliationSearch" | "checkBoxes" | "currency" | "date" | "dateRange" | "email" | "licenseSearch" | "metadataStandardSearch" | "multiselectBox" | "numberRange" | "numberWithContext" | "radioButtons" | "repositorySearch" | "researchOutputTable" | "selectBox" | "table" | "text" | "textArea" | "url";
-    meta?: {
-        schemaVersion?: string | undefined;
-    } | undefined;
-}>;
+};
 export type AnswerType = z.infer<typeof AnswerSchema>;
+export declare const AnswerJSONSchema: z.core.JSONSchema.JSONSchema;

package/dist/answers/answer.js

@@ -1,12 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnswerSchema = void 0;
+exports.AnswerJSONSchema = exports.DefaultAnswer = exports.AnswerSchema = void 0;
 const zod_1 = require("zod");
-const question_1 = require("../questions/question");
+const questions_1 = require("../questions");
 // Abstract base schema for all answers
 exports.AnswerSchema = zod_1.z.object({
-    type: question_1.QuestionFormatsEnum, // The type of answer
+    type: questions_1.QuestionFormatsEnum, // The type of answer
     meta: zod_1.z.object({
-        schemaVersion: zod_1.z.string().default(question_1.CURRENT_SCHEMA_VERSION), // The schema version of the answer
-    }).default({})
+        schemaVersion: zod_1.z.string().default(questions_1.CURRENT_SCHEMA_VERSION), // The schema version of the answer
+    })
 });
+exports.DefaultAnswer = exports.AnswerSchema.parse({
+    type: 'textArea',
+    answer: "",
+    meta: questions_1.DefaultMeta
+});
+exports.AnswerJSONSchema = zod_1.z.toJSONSchema(exports.AnswerSchema);

package/dist/answers/dateAnswers.d.ts

@@ -1,66 +1,39 @@
 import { z } from 'zod';
 export declare const DateAnswerSchema: z.ZodObject<{
-    meta: z.ZodDefault<z.ZodObject<{
-        schemaVersion: z.ZodDefault<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        schemaVersion: string;
-    }, {
-        schemaVersion?: string | undefined;
-    }>>;
-} & {
     type: z.ZodLiteral<"date">;
     answer: z.ZodDefault<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
+    meta: z.ZodObject<{
+        schemaVersion: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const DefaultDateAnswer: {
     type: "date";
+    answer: string;
     meta: {
         schemaVersion: string;
     };
-    answer: string;
-}, {
-    type: "date";
-    meta?: {
-        schemaVersion?: string | undefined;
-    } | undefined;
-    answer?: string | undefined;
-}>;
+};
 export declare const DateRangeAnswerSchema: z.ZodObject<{
-    meta: z.ZodDefault<z.ZodObject<{
-        schemaVersion: z.ZodDefault<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        schemaVersion: string;
-    }, {
-        schemaVersion?: string | undefined;
-    }>>;
-} & {
     type: z.ZodLiteral<"dateRange">;
-    answer: z.ZodDefault<z.ZodObject<{
+    answer: z.ZodObject<{
         start: z.ZodDefault<z.ZodString>;
         end: z.ZodDefault<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        start: string;
-        end: string;
-    }, {
-        start?: string | undefined;
-        end?: string | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
+    }, z.core.$strip>;
+    meta: z.ZodObject<{
+        schemaVersion: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const DefaultDateRangeAnswer: {
     type: "dateRange";
-    meta: {
-        schemaVersion: string;
-    };
     answer: {
         start: string;
         end: string;
     };
-}, {
-    type: "dateRange";
-    meta?: {
-        schemaVersion?: string | undefined;
-    } | undefined;
-    answer?: {
-        start?: string | undefined;
-        end?: string | undefined;
-    } | undefined;
-}>;
+    meta: {
+        schemaVersion: string;
+    };
+};
 export type DateAnswerType = z.infer<typeof DateAnswerSchema>;
 export type DateRangeAnswerType = z.infer<typeof DateRangeAnswerSchema>;
+export declare const DateAnswerJSONSchema: z.core.JSONSchema.JSONSchema;
+export declare const DateRangeAnswerJSONSchema: z.core.JSONSchema.JSONSchema;

package/dist/answers/dateAnswers.js

@@ -1,17 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DateRangeAnswerSchema = exports.DateAnswerSchema = void 0;
+exports.DateRangeAnswerJSONSchema = exports.DateAnswerJSONSchema = exports.DefaultDateRangeAnswer = exports.DateRangeAnswerSchema = exports.DefaultDateAnswer = exports.DateAnswerSchema = void 0;
 const zod_1 = require("zod");
 const answer_1 = require("./answer");
+const questions_1 = require("../questions");
 // Answers to Date Question Types
-exports.DateAnswerSchema = answer_1.AnswerSchema.merge(zod_1.z.object({
-    type: zod_1.z.literal('date'),
-    answer: zod_1.z.string().default('')
-}));
-exports.DateRangeAnswerSchema = answer_1.AnswerSchema.merge(zod_1.z.object({
-    type: zod_1.z.literal('dateRange'),
-    answer: zod_1.z.object({
+exports.DateAnswerSchema = zod_1.z.object(Object.assign(Object.assign({}, answer_1.AnswerSchema.shape), { type: zod_1.z.literal('date'), answer: zod_1.z.string().default('') }));
+exports.DefaultDateAnswer = exports.DateAnswerSchema.parse({
+    type: 'date',
+    answer: '',
+    meta: questions_1.DefaultMeta
+});
+exports.DateRangeAnswerSchema = zod_1.z.object(Object.assign(Object.assign({}, answer_1.AnswerSchema.shape), { type: zod_1.z.literal('dateRange'), answer: zod_1.z.object({
         start: zod_1.z.string().default(''), // The start date (string)
         end: zod_1.z.string().default('') // The end date (string)
-    }).default({})
-}));
+    }) }));
+exports.DefaultDateRangeAnswer = exports.DateRangeAnswerSchema.parse({
+    type: 'dateRange',
+    answer: {
+        start: '',
+        end: ''
+    },
+    meta: questions_1.DefaultMeta
+});
+exports.DateAnswerJSONSchema = zod_1.z.toJSONSchema(exports.DateAnswerSchema);
+exports.DateRangeAnswerJSONSchema = zod_1.z.toJSONSchema(exports.DateRangeAnswerSchema);

package/dist/answers/graphQLAnswers.d.ts

@@ -1,161 +1,89 @@
 import { z } from 'zod';
 export declare const AffiliationSearchAnswerSchema: z.ZodObject<{
-    meta: z.ZodDefault<z.ZodObject<{
-        schemaVersion: z.ZodDefault<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        schemaVersion: string;
-    }, {
-        schemaVersion?: string | undefined;
-    }>>;
-} & {
     type: z.ZodLiteral<"affiliationSearch">;
-    answer: z.ZodDefault<z.ZodObject<{
+    answer: z.ZodObject<{
         affiliationId: z.ZodDefault<z.ZodString>;
         affiliationName: z.ZodDefault<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        affiliationId: string;
-        affiliationName: string;
-    }, {
-        affiliationId?: string | undefined;
-        affiliationName?: string | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
+    }, z.core.$strip>;
+    meta: z.ZodObject<{
+        schemaVersion: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const DefaultAffiliationSearchAnswer: {
     type: "affiliationSearch";
-    meta: {
-        schemaVersion: string;
-    };
     answer: {
         affiliationId: string;
         affiliationName: string;
     };
-}, {
-    type: "affiliationSearch";
-    meta?: {
-        schemaVersion?: string | undefined;
-    } | undefined;
-    answer?: {
-        affiliationId?: string | undefined;
-        affiliationName?: string | undefined;
-    } | undefined;
-}>;
-export declare const LicenseSearchAnswerSchema: z.ZodObject<{
-    meta: z.ZodDefault<z.ZodObject<{
-        schemaVersion: z.ZodDefault<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
+    meta: {
         schemaVersion: string;
-    }, {
-        schemaVersion?: string | undefined;
-    }>>;
-} & {
+    };
+};
+export declare const LicenseSearchAnswerSchema: z.ZodObject<{
     type: z.ZodLiteral<"licenseSearch">;
-    answer: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodObject<{
+    answer: z.ZodDefault<z.ZodArray<z.ZodObject<{
         licenseId: z.ZodDefault<z.ZodString>;
         licenseName: z.ZodDefault<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        licenseId: string;
-        licenseName: string;
-    }, {
-        licenseId?: string | undefined;
-        licenseName?: string | undefined;
-    }>>, "many">>;
-}, "strip", z.ZodTypeAny, {
+    }, z.core.$strip>>>;
+    meta: z.ZodObject<{
+        schemaVersion: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const DefaultLicenseSearchAnswer: {
     type: "licenseSearch";
-    meta: {
-        schemaVersion: string;
-    };
     answer: {
         licenseId: string;
         licenseName: string;
     }[];
-}, {
-    type: "licenseSearch";
-    meta?: {
-        schemaVersion?: string | undefined;
-    } | undefined;
-    answer?: ({
-        licenseId?: string | undefined;
-        licenseName?: string | undefined;
-    } | undefined)[] | undefined;
-}>;
-export declare const MetadataStandardSearchAnswerSchema: z.ZodObject<{
-    meta: z.ZodDefault<z.ZodObject<{
-        schemaVersion: z.ZodDefault<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
+    meta: {
         schemaVersion: string;
-    }, {
-        schemaVersion?: string | undefined;
-    }>>;
-} & {
+    };
+};
+export declare const MetadataStandardSearchAnswerSchema: z.ZodObject<{
     type: z.ZodLiteral<"metadataStandardSearch">;
-    answer: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodObject<{
+    answer: z.ZodDefault<z.ZodArray<z.ZodObject<{
         metadataStandardId: z.ZodDefault<z.ZodString>;
         metadataStandardName: z.ZodDefault<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        metadataStandardId: string;
-        metadataStandardName: string;
-    }, {
-        metadataStandardId?: string | undefined;
-        metadataStandardName?: string | undefined;
-    }>>, "many">>;
-}, "strip", z.ZodTypeAny, {
+    }, z.core.$strip>>>;
+    meta: z.ZodObject<{
+        schemaVersion: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const DefaultMetadataStandardSearchAnswer: {
     type: "metadataStandardSearch";
-    meta: {
-        schemaVersion: string;
-    };
     answer: {
         metadataStandardId: string;
         metadataStandardName: string;
     }[];
-}, {
-    type: "metadataStandardSearch";
-    meta?: {
-        schemaVersion?: string | undefined;
-    } | undefined;
-    answer?: ({
-        metadataStandardId?: string | undefined;
-        metadataStandardName?: string | undefined;
-    } | undefined)[] | undefined;
-}>;
-export declare const RepositorySearchAnswerSchema: z.ZodObject<{
-    meta: z.ZodDefault<z.ZodObject<{
-        schemaVersion: z.ZodDefault<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
+    meta: {
         schemaVersion: string;
-    }, {
-        schemaVersion?: string | undefined;
-    }>>;
-} & {
+    };
+};
+export declare const RepositorySearchAnswerSchema: z.ZodObject<{
     type: z.ZodLiteral<"repositorySearch">;
-    answer: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodObject<{
+    answer: z.ZodDefault<z.ZodArray<z.ZodObject<{
         repositoryId: z.ZodDefault<z.ZodString>;
         repositoryName: z.ZodDefault<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        repositoryId: string;
-        repositoryName: string;
-    }, {
-        repositoryId?: string | undefined;
-        repositoryName?: string | undefined;
-    }>>, "many">>;
-}, "strip", z.ZodTypeAny, {
+    }, z.core.$strip>>>;
+    meta: z.ZodObject<{
+        schemaVersion: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const DefaultRepositorySearchAnswer: {
     type: "repositorySearch";
-    meta: {
-        schemaVersion: string;
-    };
     answer: {
         repositoryId: string;
         repositoryName: string;
     }[];
-}, {
-    type: "repositorySearch";
-    meta?: {
-        schemaVersion?: string | undefined;
-    } | undefined;
-    answer?: ({
-        repositoryId?: string | undefined;
-        repositoryName?: string | undefined;
-    } | undefined)[] | undefined;
-}>;
+    meta: {
+        schemaVersion: string;
+    };
+};
 export type AffiliationSearchAnswerType = z.infer<typeof AffiliationSearchAnswerSchema>;
 export type LicenseSearchAnswerType = z.infer<typeof LicenseSearchAnswerSchema>;
 export type MetadataStandardSearchAnswerType = z.infer<typeof MetadataStandardSearchAnswerSchema>;
 export type RepositorySearchAnswerType = z.infer<typeof RepositorySearchAnswerSchema>;
+export declare const AffiliationSearchAnswerJSONSchema: z.core.JSONSchema.JSONSchema;
+export declare const LicenseSearchAnswerJSONSchema: z.core.JSONSchema.JSONSchema;
+export declare const MetadataStandardSearchAnswerJSONSchema: z.core.JSONSchema.JSONSchema;
+export declare const RepositorySearchAnswerJSONSchema: z.core.JSONSchema.JSONSchema;