@skmtc/core 0.0.491 → 0.0.492

package/script/types/GeneratorKeys.d.ts

@@ -0,0 +1,50 @@
+import "../_dnt.polyfills.js";
+import type { OasOperation } from '../oas/operation/Operation.js';
+import type { Brand } from './Brand.js';
+import type { RefName } from './RefName.js';
+import { type Method } from './Method.js';
+export type NakedOperationGeneratorKey = `${string}|${string}|${Method}`;
+export type NakedModelGeneratorKey = `${string}|${string}`;
+export type OperationGeneratorKey = Brand<NakedOperationGeneratorKey, 'OperationGeneratorKey'>;
+export type ModelGeneratorKey = Brand<NakedModelGeneratorKey, 'ModelGeneratorKey'>;
+export type GeneratorOnlyKey = Brand<string, 'GeneratorOnlyKey'>;
+export type GeneratorKey = OperationGeneratorKey | ModelGeneratorKey | GeneratorOnlyKey;
+type ToOperationGeneratorKeyArgs = {
+    generatorId: string;
+    path: string;
+    method: Method;
+} | {
+    generatorId: string;
+    operation: OasOperation;
+};
+export declare const toOperationGeneratorKey: ({ generatorId, ...rest }: ToOperationGeneratorKeyArgs) => OperationGeneratorKey;
+type ToModelGeneratorKeyArgs = {
+    generatorId: string;
+    refName: RefName;
+};
+export declare const toModelGeneratorKey: ({ generatorId, refName }: ToModelGeneratorKeyArgs) => ModelGeneratorKey;
+type ToGeneratorOnlyKeyArgs = {
+    generatorId: string;
+};
+export declare const toGeneratorOnlyKey: ({ generatorId }: ToGeneratorOnlyKeyArgs) => GeneratorOnlyKey;
+export declare const isGeneratorKey: (arg: unknown) => arg is GeneratorKey;
+export declare const isOperationGeneratorKey: (arg: unknown) => arg is OperationGeneratorKey;
+export declare const isModelGeneratorKey: (arg: unknown) => arg is ModelGeneratorKey;
+export declare const isGeneratorOnlyKey: (arg: unknown) => arg is GeneratorOnlyKey;
+export declare const toGeneratorId: (generatorKey: GeneratorKey) => string;
+export type GeneratorKeyObject = {
+    type: 'operation';
+    generatorId: string;
+    path: string;
+    method: Method;
+} | {
+    type: 'model';
+    generatorId: string;
+    refName: string;
+} | {
+    type: 'generator-only';
+    generatorId: string;
+};
+export declare const fromGeneratorKey: (generatorKey: GeneratorKey) => GeneratorKeyObject;
+export {};
+//# sourceMappingURL=GeneratorKeys.d.ts.map

package/script/types/GeneratorKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeneratorKeys.d.ts","sourceRoot":"","sources":["../../src/types/GeneratorKeys.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EAAE,KAAK,MAAM,EAAY,MAAM,aAAa,CAAA;AAEnD,MAAM,MAAM,0BAA0B,GAAG,GAAG,MAAM,IAAI,MAAM,IAAI,MAAM,EAAE,CAAA;AAExE,MAAM,MAAM,sBAAsB,GAAG,GAAG,MAAM,IAAI,MAAM,EAAE,CAAA;AAE1D,MAAM,MAAM,qBAAqB,GAAG,KAAK,CACvC,0BAA0B,EAC1B,uBAAuB,CACxB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG,KAAK,CACnC,sBAAsB,EACtB,mBAAmB,CACpB,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;AAEhE,MAAM,MAAM,YAAY,GACpB,qBAAqB,GACrB,iBAAiB,GACjB,gBAAgB,CAAA;AAEpB,KAAK,2BAA2B,GAC5B;IACE,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;CACf,GACD;IACE,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,YAAY,CAAA;CACxB,CAAA;AAEL,eAAO,MAAM,uBAAuB,6BAGjC,2BAA2B,KAAG,qBAMhC,CAAA;AAED,KAAK,uBAAuB,GAAG;IAC7B,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,eAAO,MAAM,mBAAmB,6BAG7B,uBAAuB,KAAG,iBAI5B,CAAA;AAED,KAAK,sBAAsB,GAAG;IAC5B,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,eAAO,MAAM,kBAAkB,oBAE5B,sBAAsB,KAAG,gBAI3B,CAAA;AAED,eAAO,MAAM,cAAc,QAAS,OAAO,KAAG,GAAG,IAAI,YAMpD,CAAA;AAED,eAAO,MAAM,uBAAuB,QAC7B,OAAO,KACX,GAAG,IAAI,qBA0BT,CAAA;AAED,eAAO,MAAM,mBAAmB,QAAS,OAAO,KAAG,GAAG,IAAI,iBAsBzD,CAAA;AAED,eAAO,MAAM,kBAAkB,QAAS,OAAO,KAAG,GAAG,IAAI,gBAMxD,CAAA;AAED,eAAO,MAAM,aAAa,iBAAkB,YAAY,KAAG,MAU1D,CAAA;AAED,MAAM,MAAM,kBAAkB,GAC1B;IACE,IAAI,EAAE,WAAW,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;CACf,GACD;IACE,IAAI,EAAE,OAAO,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;CAChB,GACD;IACE,IAAI,EAAE,gBAAgB,CAAA;IACtB,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAEL,eAAO,MAAM,gBAAgB,iBACb,YAAY,KACzB,kBAYF,CAAA"}

package/script/types/GeneratorKeys.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromGeneratorKey = exports.toGeneratorId = exports.isGeneratorOnlyKey = exports.isModelGeneratorKey = exports.isOperationGeneratorKey = exports.isGeneratorKey = exports.toGeneratorOnlyKey = exports.toModelGeneratorKey = exports.toOperationGeneratorKey = void 0;
+require("../_dnt.polyfills.js");
+const Method_js_1 = require("./Method.js");
+const toOperationGeneratorKey = ({ generatorId, ...rest }) => {
+    const { path, method } = 'operation' in rest ? rest.operation : rest;
+    const nakedKey = `${generatorId}|${path}|${method}`;
+    return nakedKey;
+};
+exports.toOperationGeneratorKey = toOperationGeneratorKey;
+const toModelGeneratorKey = ({ generatorId, refName }) => {
+    const nakedKey = `${generatorId}|${refName}`;
+    return nakedKey;
+};
+exports.toModelGeneratorKey = toModelGeneratorKey;
+const toGeneratorOnlyKey = ({ generatorId }) => {
+    const nakedKey = `${generatorId}`;
+    return nakedKey;
+};
+exports.toGeneratorOnlyKey = toGeneratorOnlyKey;
+const isGeneratorKey = (arg) => {
+    return ((0, exports.isModelGeneratorKey)(arg) ||
+        (0, exports.isOperationGeneratorKey)(arg) ||
+        (0, exports.isGeneratorOnlyKey)(arg));
+};
+exports.isGeneratorKey = isGeneratorKey;
+const isOperationGeneratorKey = (arg) => {
+    if (typeof arg !== 'string') {
+        return false;
+    }
+    const keyTokens = arg.split('|');
+    if (keyTokens.length !== 3) {
+        return false;
+    }
+    const [generatorId, path, method] = keyTokens;
+    if (typeof generatorId !== 'string' || !generatorId.length) {
+        return false;
+    }
+    if (typeof path !== 'string' || !path.length) {
+        return false;
+    }
+    if (!(0, Method_js_1.isMethod)(method)) {
+        return false;
+    }
+    return true;
+};
+exports.isOperationGeneratorKey = isOperationGeneratorKey;
+const isModelGeneratorKey = (arg) => {
+    if (typeof arg !== 'string') {
+        return false;
+    }
+    const keyTokens = arg.split('|');
+    if (keyTokens.length !== 2) {
+        return false;
+    }
+    const [generatorId, refName] = keyTokens;
+    if (typeof generatorId !== 'string' || !generatorId.length) {
+        return false;
+    }
+    if (typeof refName !== 'string' || !refName.length) {
+        return false;
+    }
+    return true;
+};
+exports.isModelGeneratorKey = isModelGeneratorKey;
+const isGeneratorOnlyKey = (arg) => {
+    if (typeof arg !== 'string') {
+        return false;
+    }
+    return Boolean(arg.length);
+};
+exports.isGeneratorOnlyKey = isGeneratorOnlyKey;
+const toGeneratorId = (generatorKey) => {
+    if ((0, exports.isOperationGeneratorKey)(generatorKey)) {
+        return generatorKey.split('|')[0];
+    }
+    if ((0, exports.isModelGeneratorKey)(generatorKey)) {
+        return generatorKey.split('|')[0];
+    }
+    return generatorKey;
+};
+exports.toGeneratorId = toGeneratorId;
+const fromGeneratorKey = (generatorKey) => {
+    if ((0, exports.isOperationGeneratorKey)(generatorKey)) {
+        const [generatorId, path, method] = generatorKey.split('|');
+        return { type: 'operation', generatorId, path, method: method };
+    }
+    if ((0, exports.isModelGeneratorKey)(generatorKey)) {
+        const [generatorId, refName] = generatorKey.split('|');
+        return { type: 'model', generatorId, refName };
+    }
+    return { type: 'generator-only', generatorId: generatorKey };
+};
+exports.fromGeneratorKey = fromGeneratorKey;

package/script/types/GeneratorType.d.ts

@@ -0,0 +1,9 @@
+import type { OperationGateway } from '../dsl/operation/OperationInsertable.js';
+import type { OperationInsertable } from '../dsl/operation/OperationInsertable.js';
+import type { ModelInsertable } from '../dsl/model/ModelInsertable.js';
+import type { GeneratedValue } from './GeneratedValue.js';
+export type GeneratorType<EnrichmentType> = OperationGateway<EnrichmentType> | OperationInsertable<GeneratedValue, EnrichmentType> | ModelInsertable<GeneratedValue, EnrichmentType>;
+export type GeneratorsMap<G extends GeneratorType<EnrichmentType>, EnrichmentType> = {
+    [K in keyof G]: G[K];
+};
+//# sourceMappingURL=GeneratorType.d.ts.map

package/script/types/GeneratorType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeneratorType.d.ts","sourceRoot":"","sources":["../../src/types/GeneratorType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAA;AAC/E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAA;AAClF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AACtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEzD,MAAM,MAAM,aAAa,CAAC,cAAc,IACpC,gBAAgB,CAAC,cAAc,CAAC,GAChC,mBAAmB,CAAC,cAAc,EAAE,cAAc,CAAC,GACnD,eAAe,CAAC,cAAc,EAAE,cAAc,CAAC,CAAA;AAEnD,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,aAAa,CAAC,cAAc,CAAC,EAAE,cAAc,IAAI;KAClF,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACrB,CAAA"}

package/script/types/GeneratorType.js

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

package/script/types/Manifest.d.ts

@@ -0,0 +1,121 @@
+import "../_dnt.polyfills.js";
+import type { GeneratorKey } from './GeneratorKeys.js';
+import { z } from 'zod';
+import { type ResultsItem } from './Results.js';
+export type ManifestEntry = {
+    numberOfLines: number;
+    numberOfCharacters: number;
+    hash: string;
+    generatorKeys: GeneratorKey[];
+    destinationPath: string;
+};
+export declare const manifestEntry: z.ZodObject<{
+    numberOfLines: z.ZodNumber;
+    numberOfCharacters: z.ZodNumber;
+    hash: z.ZodString;
+    generatorKeys: z.ZodArray<z.ZodEffects<z.ZodString, GeneratorKey, string>, "many">;
+    destinationPath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    numberOfLines: number;
+    numberOfCharacters: number;
+    hash: string;
+    generatorKeys: GeneratorKey[];
+    destinationPath: string;
+}, {
+    numberOfLines: number;
+    numberOfCharacters: number;
+    hash: string;
+    generatorKeys: string[];
+    destinationPath: string;
+}>;
+export type PreviewItem = {
+    name: string;
+    exportPath: string;
+};
+export declare const previewItem: z.ZodObject<{
+    name: z.ZodString;
+    exportPath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    exportPath: string;
+}, {
+    name: string;
+    exportPath: string;
+}>;
+export type ManifestContent = {
+    deploymentId: string;
+    traceId: string;
+    spanId: string;
+    region?: string;
+    files: Record<string, ManifestEntry>;
+    previews: Record<string, Record<string, string>>;
+    pinnable: Partial<Record<GeneratorKey, string>>;
+    results: ResultsItem;
+    startAt: number;
+    endAt: number;
+};
+export declare const manifestContent: z.ZodObject<{
+    deploymentId: z.ZodString;
+    traceId: z.ZodString;
+    spanId: z.ZodString;
+    region: z.ZodOptional<z.ZodString>;
+    files: z.ZodRecord<z.ZodString, z.ZodObject<{
+        numberOfLines: z.ZodNumber;
+        numberOfCharacters: z.ZodNumber;
+        hash: z.ZodString;
+        generatorKeys: z.ZodArray<z.ZodEffects<z.ZodString, GeneratorKey, string>, "many">;
+        destinationPath: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        numberOfLines: number;
+        numberOfCharacters: number;
+        hash: string;
+        generatorKeys: GeneratorKey[];
+        destinationPath: string;
+    }, {
+        numberOfLines: number;
+        numberOfCharacters: number;
+        hash: string;
+        generatorKeys: string[];
+        destinationPath: string;
+    }>>;
+    previews: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>;
+    pinnable: z.ZodRecord<z.ZodEffects<z.ZodString, GeneratorKey, string>, z.ZodString>;
+    results: z.ZodType<ResultsItem, z.ZodTypeDef, ResultsItem>;
+    startAt: z.ZodNumber;
+    endAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    deploymentId: string;
+    traceId: string;
+    spanId: string;
+    files: Record<string, {
+        numberOfLines: number;
+        numberOfCharacters: number;
+        hash: string;
+        generatorKeys: GeneratorKey[];
+        destinationPath: string;
+    }>;
+    previews: Record<string, Record<string, string>>;
+    pinnable: Partial<Record<GeneratorKey, string>>;
+    results: ResultsItem;
+    startAt: number;
+    endAt: number;
+    region?: string | undefined;
+}, {
+    deploymentId: string;
+    traceId: string;
+    spanId: string;
+    files: Record<string, {
+        numberOfLines: number;
+        numberOfCharacters: number;
+        hash: string;
+        generatorKeys: string[];
+        destinationPath: string;
+    }>;
+    previews: Record<string, Record<string, string>>;
+    pinnable: Record<string, string>;
+    results: ResultsItem;
+    startAt: number;
+    endAt: number;
+    region?: string | undefined;
+}>;
+//# sourceMappingURL=Manifest.d.ts.map

package/script/types/Manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Manifest.d.ts","sourceRoot":"","sources":["../../src/types/Manifest.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACtD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,cAAc,CAAA;AAE5D,MAAM,MAAM,aAAa,GAAG;IAC1B,aAAa,EAAE,MAAM,CAAA;IACrB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,YAAY,EAAE,CAAA;IAC7B,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;EAMxB,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,eAAO,MAAM,WAAW;;;;;;;;;EAGtB,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IACpC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAChD,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAA;IAC/C,OAAO,EAAE,WAAW,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW1B,CAAA"}

package/script/types/Manifest.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manifestContent = exports.previewItem = exports.manifestEntry = void 0;
+require("../_dnt.polyfills.js");
+const GeneratorKeys_js_1 = require("./GeneratorKeys.js");
+const zod_1 = require("zod");
+const Results_js_1 = require("./Results.js");
+exports.manifestEntry = zod_1.z.object({
+    numberOfLines: zod_1.z.number(),
+    numberOfCharacters: zod_1.z.number(),
+    hash: zod_1.z.string(),
+    generatorKeys: zod_1.z.array(zod_1.z.string().refine(GeneratorKeys_js_1.isGeneratorKey)),
+    destinationPath: zod_1.z.string()
+});
+exports.previewItem = zod_1.z.object({
+    name: zod_1.z.string(),
+    exportPath: zod_1.z.string()
+});
+exports.manifestContent = zod_1.z.object({
+    deploymentId: zod_1.z.string(),
+    traceId: zod_1.z.string(),
+    spanId: zod_1.z.string(),
+    region: zod_1.z.string().optional(),
+    files: zod_1.z.record(exports.manifestEntry),
+    previews: zod_1.z.record(zod_1.z.string(), zod_1.z.record(zod_1.z.string())),
+    pinnable: zod_1.z.record(zod_1.z.string().refine(GeneratorKeys_js_1.isGeneratorKey), zod_1.z.string()),
+    results: Results_js_1.resultsItem,
+    startAt: zod_1.z.number(),
+    endAt: zod_1.z.number()
+});

package/script/types/Method.d.ts

@@ -0,0 +1,11 @@
+import "../_dnt.polyfills.js";
+import { z } from 'zod';
+export declare const methodValues: readonly ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+export declare const methodValuesNoTrace: string[];
+export declare const method: z.ZodType<Method>;
+export type Method = 'get' | 'put' | 'post' | 'delete' | 'options' | 'head' | 'patch' | 'trace';
+type Methods = Method[];
+export declare const methods: z.ZodType<Methods>;
+export declare const isMethod: (arg: unknown) => arg is Method;
+export {};
+//# sourceMappingURL=Method.d.ts.map

package/script/types/Method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Method.d.ts","sourceRoot":"","sources":["../../src/types/Method.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,YAAY,gFASf,CAAA;AAEV,eAAO,MAAM,mBAAmB,UAQ/B,CAAA;AAED,eAAO,MAAM,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CASnC,CAAA;AAEF,MAAM,MAAM,MAAM,GACd,KAAK,GACL,KAAK,GACL,MAAM,GACN,QAAQ,GACR,SAAS,GACT,MAAM,GACN,OAAO,GACP,OAAO,CAAA;AAEX,KAAK,OAAO,GAAG,MAAM,EAAE,CAAA;AAEvB,eAAO,MAAM,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAmB,CAAA;AAE1D,eAAO,MAAM,QAAQ,QAAS,OAAO,KAAG,GAAG,IAAI,MAE9C,CAAA"}

package/script/types/Method.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMethod = exports.methods = exports.method = exports.methodValuesNoTrace = exports.methodValues = void 0;
+require("../_dnt.polyfills.js");
+const zod_1 = require("zod");
+exports.methodValues = [
+    'get',
+    'put',
+    'post',
+    'delete',
+    'options',
+    'head',
+    'patch',
+    'trace'
+];
+exports.methodValuesNoTrace = [
+    'get',
+    'put',
+    'post',
+    'delete',
+    'options',
+    'head',
+    'patch'
+];
+exports.method = zod_1.z.enum([
+    'get',
+    'put',
+    'post',
+    'delete',
+    'options',
+    'head',
+    'patch',
+    'trace'
+]);
+exports.methods = zod_1.z.array(exports.method);
+const isMethod = (arg) => {
+    return exports.method.safeParse(arg).success;
+};
+exports.isMethod = isMethod;

package/script/types/Modifiers.d.ts

@@ -0,0 +1,6 @@
+export type Modifiers = {
+    required?: boolean;
+    description?: string;
+    nullable?: boolean;
+};
+//# sourceMappingURL=Modifiers.d.ts.map

package/script/types/Modifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Modifiers.d.ts","sourceRoot":"","sources":["../../src/types/Modifiers.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA"}

package/script/types/Modifiers.js

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

package/script/types/RefName.d.ts

@@ -0,0 +1,4 @@
+import "../_dnt.polyfills.js";
+import type { Brand } from './Brand.js';
+export type RefName = Brand<string, 'RefName'>;
+//# sourceMappingURL=RefName.d.ts.map

package/script/types/RefName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RefName.d.ts","sourceRoot":"","sources":["../../src/types/RefName.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAEvC,MAAM,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA"}

package/script/types/RefName.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("../_dnt.polyfills.js");

package/script/types/Results.d.ts

@@ -0,0 +1,10 @@
+import "../_dnt.polyfills.js";
+import { z } from 'zod';
+export type ResultType = 'success' | 'warning' | 'error' | 'notSelected' | 'notSupported';
+export type WarningError = 'warning' | 'error';
+export declare const resultType: z.ZodEnum<["success", "warning", "error", "notSelected", "notSupported"]>;
+export interface ResultsItem {
+    [key: string]: ResultType | ResultsItem | Array<ResultsItem | null>;
+}
+export declare const resultsItem: z.ZodType<ResultsItem>;
+//# sourceMappingURL=Results.d.ts.map

package/script/types/Results.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Results.d.ts","sourceRoot":"","sources":["../../src/types/Results.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,aAAa,GAAG,cAAc,CAAA;AAEzF,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,OAAO,CAAA;AAE9C,eAAO,MAAM,UAAU,2EAAyE,CAAA;AAEhG,MAAM,WAAW,WAAW;IAC1B,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,KAAK,CAAC,WAAW,GAAG,IAAI,CAAC,CAAA;CACpE;AAED,eAAO,MAAM,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAE9C,CAAA"}

package/script/types/Results.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resultsItem = exports.resultType = void 0;
+require("../_dnt.polyfills.js");
+const zod_1 = require("zod");
+exports.resultType = zod_1.z.enum(['success', 'warning', 'error', 'notSelected', 'notSupported']);
+exports.resultsItem = zod_1.z.record(zod_1.z.lazy(() => zod_1.z.union([exports.resultsItem, exports.resultType, zod_1.z.array(exports.resultsItem.nullable())])));