@hypequery/datasets 0.23.0 → 0.24.0

package/dist/utils/zod-v3-protocol-schema.js

@@ -0,0 +1,164 @@
+import { ProtocolSchemaAdapterError, annotate, canonicalValue, nativeEnumValues, withDefault, } from './protocol-schema-conversion.js';
+function typeName(schema) {
+    return String(schema?._def?.typeName ?? 'Unknown');
+}
+function convertString(schema, path) {
+    const result = { kind: 'string' };
+    for (const check of schema._def.checks) {
+        switch (check.kind) {
+            case 'min':
+                result.minLength = check.value;
+                break;
+            case 'max':
+                result.maxLength = check.value;
+                break;
+            case 'length':
+                result.minLength = check.value;
+                result.maxLength = check.value;
+                break;
+            default:
+                throw new ProtocolSchemaAdapterError(`Unsupported Zod string check "${String(check.kind)}"`, path);
+        }
+    }
+    return annotate(schema.description, result);
+}
+function convertNumber(schema, path) {
+    const result = { kind: 'number' };
+    for (const check of schema._def.checks) {
+        switch (check.kind) {
+            case 'int':
+                result.kind = 'integer';
+                break;
+            case 'min':
+                result[check.inclusive === false ? 'exclusiveMinimum' : 'minimum'] = check.value;
+                break;
+            case 'max':
+                result[check.inclusive === false ? 'exclusiveMaximum' : 'maximum'] = check.value;
+                break;
+            case 'finite':
+                break;
+            default:
+                throw new ProtocolSchemaAdapterError(`Unsupported Zod number check "${String(check.kind)}"`, path);
+        }
+    }
+    return annotate(schema.description, result);
+}
+function isOptionalProperty(schema) {
+    const name = typeName(schema);
+    return name === 'ZodOptional' || name === 'ZodDefault';
+}
+function isUnconstrainedRecordKey(schema) {
+    if (schema === undefined || typeName(schema) !== 'ZodString')
+        return false;
+    const definition = schema._def;
+    return Array.isArray(definition.checks)
+        && definition.checks.length === 0
+        && definition.coerce !== true;
+}
+/** Converts the portable subset of a Zod 3 schema into an RFC 0004 draft. */
+export function convertZodV3Schema(schema, path) {
+    const definition = schema._def;
+    const done = (result) => annotate(schema.description, result);
+    switch (typeName(schema)) {
+        case 'ZodAny':
+        case 'ZodUnknown':
+            return done({ kind: 'any' });
+        case 'ZodNever':
+        case 'ZodVoid':
+        case 'ZodUndefined':
+            return done({ kind: 'void' });
+        case 'ZodNull':
+            return done({ kind: 'null' });
+        case 'ZodBoolean':
+            return done({ kind: 'boolean' });
+        case 'ZodString':
+            return convertString(schema, path);
+        case 'ZodNumber':
+            return convertNumber(schema, path);
+        case 'ZodLiteral':
+            return done({ kind: 'literal', value: canonicalValue(definition.value, `${path}.value`) });
+        case 'ZodEnum':
+            return done({ kind: 'enum', values: [...definition.values] });
+        case 'ZodNativeEnum':
+            return done({ kind: 'enum', values: nativeEnumValues(definition.values) });
+        case 'ZodArray': {
+            const result = {
+                kind: 'array',
+                items: convertZodV3Schema(definition.type, `${path}.items`),
+            };
+            if (definition.minLength?.value !== undefined)
+                result.minItems = definition.minLength.value;
+            if (definition.maxLength?.value !== undefined)
+                result.maxItems = definition.maxLength.value;
+            if (definition.exactLength?.value !== undefined) {
+                result.minItems = definition.exactLength.value;
+                result.maxItems = definition.exactLength.value;
+            }
+            return done(result);
+        }
+        case 'ZodObject': {
+            if (typeName(definition.catchall) !== 'ZodNever') {
+                throw new ProtocolSchemaAdapterError('Unsupported Zod object catchall', path);
+            }
+            const shape = definition.shape();
+            return done({
+                kind: 'object',
+                properties: Object.fromEntries(Object.entries(shape).map(([name, property]) => [
+                    name,
+                    convertZodV3Schema(property, `${path}.properties.${name}`),
+                ])),
+                required: Object.entries(shape)
+                    .filter(([, property]) => !isOptionalProperty(property))
+                    .map(([name]) => name),
+                unknownProperties: definition.unknownKeys === 'passthrough'
+                    ? 'preserve'
+                    : definition.unknownKeys === 'strict'
+                        ? 'reject'
+                        : 'strip',
+            });
+        }
+        case 'ZodRecord':
+            if (!isUnconstrainedRecordKey(definition.keyType)) {
+                throw new ProtocolSchemaAdapterError('Unsupported constrained Zod record key', path);
+            }
+            return done({ kind: 'record', values: convertZodV3Schema(definition.valueType, `${path}.values`) });
+        case 'ZodUnion':
+            return done({
+                kind: 'union',
+                variants: definition.options.map((option, index) => convertZodV3Schema(option, `${path}.variants[${index}]`)),
+            });
+        case 'ZodDiscriminatedUnion':
+            // RFC 0004 has no separate discriminator index. Converting every option
+            // drops only Zod's lookup metadata; each object's literal discriminator
+            // property remains part of its protocol variant.
+            return done({
+                kind: 'union',
+                variants: [...definition.options.values()].map((option, index) => convertZodV3Schema(option, `${path}.variants[${index}]`)),
+            });
+        case 'ZodNullable':
+            return done({
+                kind: 'union',
+                variants: [convertZodV3Schema(definition.innerType, `${path}.variants[0]`), { kind: 'null' }],
+            });
+        case 'ZodOptional':
+            return done(convertZodV3Schema(definition.innerType, path));
+        case 'ZodDefault':
+            return done(withDefault(convertZodV3Schema(definition.innerType, path), definition.defaultValue(), path));
+        case 'ZodBranded':
+            return done(convertZodV3Schema(definition.type, path));
+        case 'ZodReadonly':
+            return done(convertZodV3Schema(definition.innerType, path));
+        case 'ZodEffects': {
+            const effectType = String(definition.effect?.type ?? 'unknown');
+            if (effectType !== 'refinement') {
+                throw new ProtocolSchemaAdapterError(`Unsupported Zod effect "${effectType}"`, path);
+            }
+            // A refinement preserves the wrapped schema's input and output shape.
+            // The rule itself remains enforced by Zod, but cannot be advertised by
+            // ProtocolSchema (for example, a cross-field selection requirement).
+            return done(convertZodV3Schema(definition.schema, path));
+        }
+        default:
+            throw new ProtocolSchemaAdapterError(`Unsupported Zod type "${typeName(schema)}"`, path);
+    }
+}

package/dist/utils/zod-v4-protocol-schema.d.ts

@@ -0,0 +1,12 @@
+import { type ProtocolSchemaDraft } from './protocol-schema-conversion.js';
+/** A Zod 4 schema, read through `_zod.def`. Classic schemas also expose `description`. */
+type ZodV4Schema = {
+    readonly _zod: {
+        readonly def: Record<string, any>;
+    };
+    readonly description?: string;
+};
+/** Converts the portable subset of a Zod 4 schema into an RFC 0004 draft. */
+export declare function convertZodV4Schema(schema: ZodV4Schema, path: string): ProtocolSchemaDraft;
+export {};
+//# sourceMappingURL=zod-v4-protocol-schema.d.ts.map

package/dist/utils/zod-v4-protocol-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-v4-protocol-schema.d.ts","sourceRoot":"","sources":["../../src/utils/zod-v4-protocol-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,mBAAmB,EACzB,MAAM,iCAAiC,CAAC;AAEzC,0FAA0F;AAC1F,KAAK,WAAW,GAAG;IACjB,QAAQ,CAAC,IAAI,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAAE,CAAC;IACrD,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B,CAAC;AAwHF,6EAA6E;AAC7E,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,mBAAmB,CA4EzF"}

package/dist/utils/zod-v4-protocol-schema.js

@@ -0,0 +1,171 @@
+import { ProtocolSchemaAdapterError, annotate, canonicalValue, nativeEnumValues, withDefault, } from './protocol-schema-conversion.js';
+const INTEGER_FORMATS = new Set(['safeint', 'int32', 'uint32']);
+function typeOf(schema) {
+    return String(schema?._zod?.def?.type ?? 'unknown');
+}
+function checksOf(schema) {
+    return (schema._zod.def.checks ?? []).map(check => check._zod.def);
+}
+/** Zod 4 stores `.refine()` as a `custom` check on the schema it refines. */
+function isRefinement(check) {
+    return check.check === 'custom';
+}
+function applyLengthChecks(schema, result, keys, label, path) {
+    for (const check of checksOf(schema)) {
+        switch (check.check) {
+            case 'min_length':
+                result[keys.min] = check.minimum;
+                break;
+            case 'max_length':
+                result[keys.max] = check.maximum;
+                break;
+            case 'length_equals':
+                result[keys.min] = check.length;
+                result[keys.max] = check.length;
+                break;
+            default:
+                if (isRefinement(check))
+                    break;
+                throw new ProtocolSchemaAdapterError(`Unsupported Zod ${label} check "${String(check.format ?? check.check)}"`, path);
+        }
+    }
+    return result;
+}
+function convertNumber(schema, path) {
+    const result = { kind: 'number' };
+    for (const check of checksOf(schema)) {
+        switch (check.check) {
+            case 'number_format':
+                if (!INTEGER_FORMATS.has(check.format)) {
+                    throw new ProtocolSchemaAdapterError(`Unsupported Zod number check "${String(check.format)}"`, path);
+                }
+                result.kind = 'integer';
+                break;
+            case 'greater_than':
+                result[check.inclusive ? 'minimum' : 'exclusiveMinimum'] = check.value;
+                break;
+            case 'less_than':
+                result[check.inclusive ? 'maximum' : 'exclusiveMaximum'] = check.value;
+                break;
+            default:
+                if (isRefinement(check))
+                    break;
+                throw new ProtocolSchemaAdapterError(`Unsupported Zod number check "${String(check.check)}"`, path);
+        }
+    }
+    return result;
+}
+function isOptionalProperty(schema) {
+    const type = typeOf(schema);
+    return type === 'optional' || type === 'default';
+}
+function isUnconstrainedRecordKey(schema) {
+    return schema !== undefined
+        && typeOf(schema) === 'string'
+        && checksOf(schema).length === 0
+        && schema._zod.def.coerce !== true;
+}
+function unknownProperties(catchall, path) {
+    if (catchall === undefined)
+        return 'strip';
+    switch (typeOf(catchall)) {
+        case 'never':
+            return 'reject';
+        case 'unknown':
+            return 'preserve';
+        default:
+            throw new ProtocolSchemaAdapterError('Unsupported Zod object catchall', path);
+    }
+}
+function literal(values, path) {
+    if (values.length === 1) {
+        return { kind: 'literal', value: canonicalValue(values[0], `${path}.value`) };
+    }
+    return {
+        kind: 'union',
+        variants: values.map((value, index) => ({
+            kind: 'literal',
+            value: canonicalValue(value, `${path}.variants[${index}].value`),
+        })),
+    };
+}
+/**
+ * Zod 4 has no effects wrapper: a transform is a pipe into a `transform`, and
+ * a preprocessor is a pipe out of one. Neither preserves the advertised shape.
+ */
+function pipeEffect(definition) {
+    if (typeOf(definition.out) === 'transform')
+        return 'transform';
+    if (typeOf(definition.in) === 'transform')
+        return 'preprocess';
+    return 'pipe';
+}
+/** Converts the portable subset of a Zod 4 schema into an RFC 0004 draft. */
+export function convertZodV4Schema(schema, path) {
+    const definition = schema._zod.def;
+    const done = (result) => annotate(schema.description, result);
+    switch (typeOf(schema)) {
+        case 'any':
+        case 'unknown':
+            return done({ kind: 'any' });
+        case 'never':
+        case 'void':
+        case 'undefined':
+            return done({ kind: 'void' });
+        case 'null':
+            return done({ kind: 'null' });
+        case 'boolean':
+            return done({ kind: 'boolean' });
+        case 'string':
+            return done(applyLengthChecks(schema, { kind: 'string' }, { min: 'minLength', max: 'maxLength' }, 'string', path));
+        case 'number':
+            return done(convertNumber(schema, path));
+        case 'literal':
+            return done(literal(definition.values, path));
+        case 'enum':
+            return done({ kind: 'enum', values: nativeEnumValues(definition.entries) });
+        case 'array':
+            return done(applyLengthChecks(schema, { kind: 'array', items: convertZodV4Schema(definition.element, `${path}.items`) }, { min: 'minItems', max: 'maxItems' }, 'array', path));
+        case 'object': {
+            const policy = unknownProperties(definition.catchall, path);
+            const shape = definition.shape;
+            return done({
+                kind: 'object',
+                properties: Object.fromEntries(Object.entries(shape).map(([name, property]) => [
+                    name,
+                    convertZodV4Schema(property, `${path}.properties.${name}`),
+                ])),
+                required: Object.entries(shape)
+                    .filter(([, property]) => !isOptionalProperty(property))
+                    .map(([name]) => name),
+                unknownProperties: policy,
+            });
+        }
+        case 'record':
+            if (!isUnconstrainedRecordKey(definition.keyType)) {
+                throw new ProtocolSchemaAdapterError('Unsupported constrained Zod record key', path);
+            }
+            return done({ kind: 'record', values: convertZodV4Schema(definition.valueType, `${path}.values`) });
+        case 'union':
+            // A discriminated union is a union with a `discriminator`. RFC 0004 has
+            // no discriminator index; each variant keeps its literal property.
+            return done({
+                kind: 'union',
+                variants: definition.options.map((option, index) => convertZodV4Schema(option, `${path}.variants[${index}]`)),
+            });
+        case 'nullable':
+            return done({
+                kind: 'union',
+                variants: [convertZodV4Schema(definition.innerType, `${path}.variants[0]`), { kind: 'null' }],
+            });
+        case 'optional':
+        case 'readonly':
+            return done(convertZodV4Schema(definition.innerType, path));
+        case 'default':
+            return done(withDefault(convertZodV4Schema(definition.innerType, path), definition.defaultValue, path));
+        case 'pipe':
+            throw new ProtocolSchemaAdapterError(`Unsupported Zod effect "${pipeEffect(definition)}"`, path);
+        default:
+            throw new ProtocolSchemaAdapterError(`Unsupported Zod type "${typeOf(schema)}"`, path);
+    }
+}

package/dist/validation.d.ts

@@ -17,6 +17,13 @@ export interface ValidationResult {
  * @returns true if the value matches the field type
  */
 export declare function matchesFieldType(fieldType: FieldType, value: unknown): boolean;
+/** True when a list holds both instants (`Z` or an offset) and offset-free timestamps. */
+export declare function mixesInstantsAndLocalTimes(values: readonly unknown[]): boolean;
+/**
+ * An `in` list is one predicate, so every member is read in the same zone:
+ * an instant and a local time cannot share one without changing a meaning.
+ */
+export declare function mixedInstantListError(field: string): string;
 /**
  * Validates a filter value against the expected field type.
  *

package/dist/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1D;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAY9E;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,GAAG,MAAM,GAAG,IAAI,CA0C7F"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI1D;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAgB9E;AAED,0FAA0F;AAC1F,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,CAG9E;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE3D;AAgBD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,GAAG,MAAM,GAAG,IAAI,CA6C7F"}

package/dist/validation.js

@@ -1,6 +1,8 @@
 /**
  * Shared validation utilities for semantic layer queries.
  */
+import { parseTimestampInstant } from './utils/timestamp-instants.js';
+import { isTimestampText } from './utils/timestamp-text.js';
 /**
  * Checks if a value matches the expected field type.
  *
@@ -11,16 +13,45 @@
 export function matchesFieldType(fieldType, value) {
     switch (fieldType) {
         case 'string':
-        case 'timestamp':
             return typeof value === 'string';
+        case 'timestamp':
+            return isTimestampText(value);
         case 'number':
-            return typeof value === 'number' && Number.isFinite(value);
+            // Number filters bind as Float64; an integer beyond 2^53 is already rounded
+            // and would silently match nothing against an exact Int64/UInt64 column.
+            return typeof value === 'number' && Number.isFinite(value)
+                && (!Number.isInteger(value) || Number.isSafeInteger(value));
         case 'boolean':
             return typeof value === 'boolean';
         default:
             return false;
     }
 }
+/** True when a list holds both instants (`Z` or an offset) and offset-free timestamps. */
+export function mixesInstantsAndLocalTimes(values) {
+    const instants = values.map(value => parseTimestampInstant(value) !== undefined);
+    return instants.some(Boolean) && !instants.every(Boolean);
+}
+/**
+ * An `in` list is one predicate, so every member is read in the same zone:
+ * an instant and a local time cannot share one without changing a meaning.
+ */
+export function mixedInstantListError(field) {
+    return `"in" cannot mix instants (with Z or an offset) and local timestamps for field "${field}"; use one form.`;
+}
+function typeError(filter, fieldType, plural) {
+    if (fieldType === 'timestamp') {
+        const what = plural ? 'ISO 8601 timestamps' : 'an ISO 8601 timestamp';
+        return `"${filter.operator}" expects ${what} for field "${filter.field}", such as 2026-01-31 or 2026-01-31T12:00:00Z, with a real calendar date and time.`;
+    }
+    if (fieldType === 'number') {
+        const what = plural ? 'number values' : 'a number value';
+        return `"${filter.operator}" expects ${what} for field "${filter.field}"; integers must be safe integers (within ±2^53) to compare exactly. Declare a large id as dimension.string() to filter it exactly.`;
+    }
+    return plural
+        ? `"${filter.operator}" expects ${fieldType} values for field "${filter.field}".`
+        : `"${filter.operator}" expects a ${fieldType} value for field "${filter.field}".`;
+}
 /**
  * Validates a filter value against the expected field type.
  *
@@ -34,7 +65,7 @@ export function validateFilterValue(filter, fieldType) {
         case 'neq':
             return matchesFieldType(fieldType, filter.value)
                 ? null
-                : `"${filter.operator}" expects a ${fieldType} value for field "${filter.field}".`;
+                : typeError(filter, fieldType, false);
         case 'gt':
         case 'gte':
         case 'lt':
@@ -44,7 +75,7 @@ export function validateFilterValue(filter, fieldType) {
             }
             return matchesFieldType(fieldType, filter.value)
                 ? null
-                : `"${filter.operator}" expects a ${fieldType} value for field "${filter.field}".`;
+                : typeError(filter, fieldType, false);
         case 'like':
             if (fieldType !== 'string' && fieldType !== 'timestamp') {
                 return `"like" is only supported for string or timestamp field "${filter.field}".`;
@@ -57,16 +88,19 @@ export function validateFilterValue(filter, fieldType) {
             if (!Array.isArray(filter.value) || filter.value.length === 0) {
                 return `"${filter.operator}" expects a non-empty array for field "${filter.field}".`;
             }
-            return filter.value.every(value => matchesFieldType(fieldType, value))
-                ? null
-                : `"${filter.operator}" expects ${fieldType} values for field "${filter.field}".`;
+            if (!filter.value.every(value => matchesFieldType(fieldType, value))) {
+                return typeError(filter, fieldType, true);
+            }
+            return filter.operator === 'in' && fieldType === 'timestamp' && mixesInstantsAndLocalTimes(filter.value)
+                ? mixedInstantListError(filter.field)
+                : null;
         case 'between':
             if (!Array.isArray(filter.value) || filter.value.length !== 2) {
                 return `"between" expects a two-item array for field "${filter.field}".`;
             }
             return filter.value.every(value => matchesFieldType(fieldType, value))
                 ? null
-                : `"between" expects ${fieldType} values for field "${filter.field}".`;
+                : typeError(filter, fieldType, true);
         default:
             return `Unsupported semantic filter operator "${String(filter.operator)}".`;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hypequery/datasets",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "description": "Code-first TypeScript semantic layer for ClickHouse datasets, metrics, multi-tenancy, and AI agents",
   "keywords": [
     "semantic-layer",
@@ -24,6 +24,11 @@
       "import": "./dist/index.js",
       "require": "./dist/index.js"
     },
+    "./schemas": {
+      "types": "./dist/schemas.d.ts",
+      "import": "./dist/schemas.js",
+      "require": "./dist/schemas.js"
+    },
     "./internal": {
       "types": "./dist/internal.d.ts",
       "import": "./dist/internal.js",
@@ -34,27 +39,31 @@
     "*": {
       "internal": [
         "./dist/internal.d.ts"
+      ],
+      "schemas": [
+        "./dist/schemas.d.ts"
       ]
     }
   },
   "license": "Apache-2.0",
   "files": [
-    "dist"
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/*.type-test.*",
+    "!dist/**/__tests__/**",
+    "!dist/**/tests/**",
+    "!dist/**/type-tests/**"
   ],
   "dependencies": {
-    "@hypequery/protocol": "^0.19.0",
-    "@noble/hashes": "^1.8.0",
-    "zod": "^3.22.4",
+    "@hypequery/protocol": "^0.21.0",
+    "@noble/hashes": "^2.4.0",
+    "zod": "^4.6.6",
     "zod-to-json-schema": "^3.25.2"
   },
   "peerDependencies": {
-    "zod": "^3.22.4",
     "@hypequery/clickhouse": ">=2.13.0"
   },
   "peerDependenciesMeta": {
-    "zod": {
-      "optional": true
-    },
     "@hypequery/clickhouse": {
       "optional": true
     }
@@ -62,9 +71,9 @@
   "devDependencies": {
     "@types/node": "^18.19.80",
     "typescript": "^6.0.3",
-    "@vitest/coverage-v8": "^5.0.2",
-    "vitest": "^5.0.2",
-    "@hypequery/protocol-conformance": "^0.15.1"
+    "@vitest/coverage-v8": "^5.0.5",
+    "vitest": "^5.0.5",
+    "@hypequery/protocol-conformance": "^0.16.0"
   },
   "repository": {
     "type": "git",

package/dist/api.type-test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=api.type-test.d.ts.map

package/dist/api.type-test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api.type-test.d.ts","sourceRoot":"","sources":["../src/api.type-test.ts"],"names":[],"mappings":""}