nuxt-google-sheets-import 0.1.4 → 0.1.7

package/dist/runtime/components/GoogleSheetsImportSchemaGuide.vue

@@ -1,6 +1,9 @@
 <script setup>
 import { computed, onMounted, ref, watch } from "vue";
+import { useToast } from "#imports";
 import { useGoogleSheetsImport } from "../composables/useGoogleSheetsImport";
+import { copyTextWithSuccessToast } from "../utils/clipboard";
+import { toTsvRow } from "../utils/delimited";
 const props = defineProps({
   initialSchema: { type: String, required: false, default: "" }
 });
@@ -60,58 +63,36 @@ onMounted(async () => {
     await loadColumns(selectedSchema.value);
   }
 });
-function copyColumns() {
-  const content = columns.value.join("\n");
-  if (!content) {
-    return;
-  }
-  navigator.clipboard.writeText(content);
-  toast.add({
-    title: "Copied",
+async function copyColumns() {
+  await copyTextWithSuccessToast({
+    text: columns.value.join("\n"),
+    toast,
     description: "Column names copied to clipboard.",
-    color: "success"
+    title: "Copied"
   });
 }
-function csvRow(values) {
-  return values.map((value) => {
-    const escaped = value.replaceAll('"', '""');
-    return `"${escaped}"`;
-  }).join(",");
-}
-function copyColumnsCsv() {
-  const content = csvRow(columns.value);
-  if (!content) {
-    return;
-  }
-  navigator.clipboard.writeText(content);
-  toast.add({
-    title: "Copied",
-    description: "Column names copied as a CSV row.",
-    color: "success"
+async function copyColumnsTsv() {
+  await copyTextWithSuccessToast({
+    text: toTsvRow(columns.value),
+    toast,
+    description: "Column names copied as a tab-separated row for Google Sheets.",
+    title: "Copied"
   });
 }
-function copyPageOverrideColumns() {
-  const content = pageOverrideColumns.value.join("\n");
-  if (!content) {
-    return;
-  }
-  navigator.clipboard.writeText(content);
-  toast.add({
-    title: "Copied",
+async function copyPageOverrideColumns() {
+  await copyTextWithSuccessToast({
+    text: pageOverrideColumns.value.join("\n"),
+    toast,
     description: "Page override column names copied to clipboard.",
-    color: "success"
+    title: "Copied"
   });
 }
-function copyPageOverrideColumnsCsv() {
-  const content = csvRow(pageOverrideColumns.value);
-  if (!content) {
-    return;
-  }
-  navigator.clipboard.writeText(content);
-  toast.add({
-    title: "Copied",
-    description: "Page override column names copied as a CSV row.",
-    color: "success"
+async function copyPageOverrideColumnsTsv() {
+  await copyTextWithSuccessToast({
+    text: toTsvRow(pageOverrideColumns.value),
+    toast,
+    description: "Page override column names copied as a tab-separated row for Google Sheets.",
+    title: "Copied"
   });
 }
 </script>
@@ -169,11 +150,11 @@ function copyPageOverrideColumnsCsv() {
           @click="copyColumns"
         />
         <UButton
-          label="Copy as CSV row"
+          label="Copy as tab-separated row"
           icon="i-heroicons-table-cells-20-solid"
           color="neutral"
           variant="subtle"
-          @click="copyColumnsCsv"
+          @click="copyColumnsTsv"
         />
       </div>
       <pre class="text-xs whitespace-pre-wrap">{{ columns.join("\n") }}</pre>
@@ -199,11 +180,11 @@ function copyPageOverrideColumnsCsv() {
             @click="copyPageOverrideColumns"
           />
           <UButton
-            label="Copy overrides as CSV row"
+            label="Copy overrides as tab-separated row"
             icon="i-heroicons-table-cells-20-solid"
             color="neutral"
             variant="subtle"
-            @click="copyPageOverrideColumnsCsv"
+            @click="copyPageOverrideColumnsTsv"
           />
         </div>
         <pre class="text-xs whitespace-pre-wrap">{{ pageOverrideColumns.join("\n") }}</pre>

package/dist/runtime/components/GoogleSheetsImportSource.vue

@@ -1,5 +1,8 @@
 <script setup>
 import { z } from "zod";
+import { useGoogleSheetsImportWorkflow } from "../composables/useGoogleSheetsImportWorkflow";
+import { useToast } from "#imports";
+import { watch } from "vue";
 const { googleSheets } = defineProps({
   googleSheets: { type: Array, required: true }
 });

package/dist/runtime/pages/google-sheets-import.vue

@@ -4,11 +4,42 @@ const sheetsList = ref([
   { id: "1NKS0cTX6u5urtgQ3Q4Z2motiR2-9JmyPxcd05yVc1bc", label: "Metzner" },
   { id: "1tGZCEoiikXfg3mOpfVWWTS1SSSsj18xv6Z3owrnnt4s", label: "Example Sheet" }
 ]);
+const items = ref([
+  {
+    label: "Setup Google Sheet",
+    icon: "i-lucide-layout-dashboard",
+    slot: "sheet"
+  },
+  {
+    label: "Import data",
+    icon: "i-lucide-upload",
+    slot: "import"
+  },
+  {
+    label: "Export data",
+    icon: "i-lucide-download",
+    slot: "export"
+  }
+]);
 </script>
 
 <template>
-  <UContainer>
-    <GoogleSheetsImportSchemaGuide />
-    <GoogleSheetsImportSource :google-sheets="sheetsList" />
+  <UContainer class="max-w-36">
+    <UTabs
+      :items="items"
+      variant="link"
+      color="neutral"
+      class="w-full"
+    >
+      <template #sheet>
+        <GoogleSheetsImportSchemaGuide :initial-schema="'Example Sheet'" />
+      </template>
+      <template #import>
+        <GoogleSheetsImportSource :google-sheets="sheetsList" />
+      </template>
+      <template #export>
+        <GoogleSheetsImportExport />
+      </template>
+    </UTabs>
   </UContainer>
 </template>

package/dist/runtime/server/api/collection-type.get.js

@@ -9,8 +9,7 @@ export default defineEventHandler(async (event) => {
   const { schema } = await getValidatedQuery(event, (query) => querySchema.parse(query));
   const config = useRuntimeConfig(event);
   const moduleConfig = config.googleSheetsImport;
-  const fromConfig = moduleConfig.collectionTypeBySchema ?? {};
-  const collectionType = await resolveCollectionTypeBySchema(schema, fromConfig);
+  const collectionType = await resolveCollectionTypeBySchema(schema);
   const baseContentDir = collectionType === "page" ? "content" : collectionType === "data" ? "content/data" : moduleConfig.defaultContentDir;
   return {
     schema: schema ?? null,

package/dist/runtime/server/api/schema-columns.get.js

@@ -2,15 +2,13 @@ import { z } from "zod";
 import { resolveCollectionTypeBySchema } from "../utils/collectionType.js";
 import { getSchemaColumns, PAGE_SCHEMA_OVERRIDE_COLUMNS } from "../utils/schemaColumns.js";
 import { getValidatedQuery, defineEventHandler, createError } from "h3";
-import { useRuntimeConfig } from "#imports";
+import { googleSheetsImportSchemas } from "#imports";
 const querySchema = z.object({
   schema: z.string().optional()
 });
 export default defineEventHandler(async (event) => {
   const { schema } = await getValidatedQuery(event, (query) => querySchema.parse(query));
-  const config = useRuntimeConfig(event);
-  const moduleConfig = config.googleSheetsImport;
-  const schemaMap = {};
+  const schemaMap = googleSheetsImportSchemas ?? {};
   const availableSchemas = Object.keys(schemaMap).sort((left, right) => left.localeCompare(right));
   if (!schema) {
     return {
@@ -21,7 +19,7 @@ export default defineEventHandler(async (event) => {
       pageOverrideColumns: []
     };
   }
-  const collectionType = await resolveCollectionTypeBySchema(schema, moduleConfig.collectionTypeBySchema ?? {});
+  const collectionType = await resolveCollectionTypeBySchema(schema);
   const selectedSchema = schemaMap[schema];
   if (!selectedSchema) {
     throw createError({
@@ -29,10 +27,11 @@ export default defineEventHandler(async (event) => {
       statusMessage: `Unknown schema: ${schema}`
     });
   }
+  const columns = getSchemaColumns(selectedSchema);
   return {
     schema,
     schemas: availableSchemas,
-    columns: getSchemaColumns(selectedSchema),
+    columns,
     collectionType,
     pageOverrideColumns: collectionType === "page" ? PAGE_SCHEMA_OVERRIDE_COLUMNS : []
   };

package/dist/runtime/server/api/values.post.js

@@ -1,8 +1,7 @@
 import { z } from "zod";
 import { transformAndValidateRows } from "../utils/transform.js";
 import { readBody, defineEventHandler, createError } from "h3";
-import { useRuntimeConfig } from "#imports";
-import { schemas } from "../../import/schemas.js";
+import { useRuntimeConfig, googleSheetsImportSchemas } from "#imports";
 const bodySchema = z.object({
   spreadsheetId: z.string().length(44),
   sheetTitle: z.string().min(1),
@@ -19,7 +18,7 @@ export default defineEventHandler(async (event) => {
   const encodedRange = encodeURIComponent(`${body.sheetTitle}!${body.range}`);
   const googleResponse = await $fetch(`https://sheets.googleapis.com/v4/spreadsheets/${body.spreadsheetId}/values/${encodedRange}?key=${apiKey}`);
   const values = googleResponse.values ?? [];
-  const schemaMap = schemas;
+  const schemaMap = googleSheetsImportSchemas ?? {};
   const schema = schemaMap[body.schema];
   if (!schema) {
     throw createError({ statusCode: 400, statusMessage: `Unknown schema: ${body.schema}` });

package/dist/runtime/server/api/write.post.js

@@ -25,7 +25,7 @@ function resolveContentDirByCollectionType(collectionType, schemaKey, fallback)
   }
   const normalizedSchemaKey = schemaKey.trim();
   console.warn(
-    `[google-sheets-import] No collection type mapping found for schema "${normalizedSchemaKey}". Using fallback content directory "${fallback}". Add googleSheetsImport.collectionTypeBySchema["` + normalizedSchemaKey + '"] in nuxt.config.ts to route writes automatically.'
+    `[google-sheets-import] No collection type mapping found for schema "${normalizedSchemaKey}". Using fallback content directory "${fallback}". Ensure the matching Nuxt Content collection is defined with type "page" or "data" in content.config.ts.`
   );
   return fallback;
 }
@@ -33,8 +33,7 @@ export default defineEventHandler(async (event) => {
   const body = bodySchema.parse(await readBody(event));
   const config = useRuntimeConfig(event);
   const moduleConfig = config.googleSheetsImport;
-  const mappedInConfig = moduleConfig.collectionTypeBySchema ?? {};
-  const resolvedCollectionType = await resolveCollectionTypeBySchema(body.schema, mappedInConfig);
+  const resolvedCollectionType = await resolveCollectionTypeBySchema(body.schema);
   const resolvedContentDir = body.contentDir ?? resolveContentDirByCollectionType(resolvedCollectionType, body.schema, moduleConfig.defaultContentDir);
   const logs = [];
   const summary = {

package/dist/runtime/server/utils/collectionType.d.ts

@@ -1,3 +1,3 @@
 type CollectionType = 'page' | 'data';
-export declare function resolveCollectionTypeBySchema(schemaKey: string | undefined, collectionTypeBySchemaFromConfig: Record<string, CollectionType>): Promise<CollectionType | 'unknown'>;
+export declare function resolveCollectionTypeBySchema(schemaKey: string | undefined): Promise<CollectionType | 'unknown'>;
 export {};

package/dist/runtime/server/utils/collectionType.js

@@ -12,46 +12,55 @@ function setCollectionType(map, key, type) {
     map[normalized] = type;
   }
 }
-async function readCollectionTypeBySchemaFromContentConfig() {
-  if (cachedCollectionTypeBySchema) {
-    return cachedCollectionTypeBySchema;
-  }
+function parseManifestSource(source) {
   const result = {};
-  try {
-    const contentConfigPath = path.resolve(process.cwd(), "content.config.ts");
-    const source = await readFile(contentConfigPath, "utf-8");
-    const collectionTypeMatches = source.matchAll(/(\w+)\s*:\s*defineCollection\([\s\S]{0,900}?type:\s*['"](page|data)['"]/g);
-    for (const match of collectionTypeMatches) {
-      const collectionName = match[1];
-      const collectionType = match[2];
-      if (collectionName) {
-        setCollectionType(result, collectionName, collectionType);
-      }
+  const schemas = /* @__PURE__ */ new Set();
+  const defaultExportIndex = source.indexOf("export default");
+  const manifestCollectionsSource = defaultExportIndex === -1 ? source : source.slice(defaultExportIndex);
+  const collectionTypeMatches = manifestCollectionsSource.matchAll(/"([^"\n]+)"\s*:\s*\{[\s\S]{0,500}?"type"\s*:\s*"(page|data)"/g);
+  for (const match of collectionTypeMatches) {
+    const collectionName = match[1];
+    const collectionType = match[2];
+    if (collectionName) {
+      schemas.add(collectionName);
+      setCollectionType(result, collectionName, collectionType);
     }
-    const schemaTypeMatches = source.matchAll(/type:\s*['"](page|data)['"][\s\S]{0,900}?schema:\s*schemas\.(\w+)/g);
-    for (const match of schemaTypeMatches) {
-      const collectionType = match[1];
-      const schemaKey = match[2];
-      if (schemaKey) {
-        setCollectionType(result, schemaKey, collectionType);
-      }
+  }
+  return {
+    collectionTypeBySchema: result,
+    schemas: Array.from(schemas).sort((left, right) => left.localeCompare(right))
+  };
+}
+async function readManifestData() {
+  const candidates = [
+    path.resolve(process.cwd(), ".nuxt/content/manifest.ts"),
+    path.resolve(process.cwd(), ".nuxt/content/manifest.mjs")
+  ];
+  for (const manifestPath of candidates) {
+    try {
+      const source = await readFile(manifestPath, "utf-8");
+      return parseManifestSource(source);
+    } catch {
     }
-  } catch {
-    cachedCollectionTypeBySchema = {};
+  }
+  return {
+    collectionTypeBySchema: {},
+    schemas: []
+  };
+}
+async function readCollectionTypeBySchema() {
+  if (cachedCollectionTypeBySchema) {
     return cachedCollectionTypeBySchema;
   }
-  cachedCollectionTypeBySchema = result;
+  const fromManifest = await readManifestData();
+  cachedCollectionTypeBySchema = fromManifest.collectionTypeBySchema;
   return cachedCollectionTypeBySchema;
 }
-export async function resolveCollectionTypeBySchema(schemaKey, collectionTypeBySchemaFromConfig) {
+export async function resolveCollectionTypeBySchema(schemaKey) {
   if (!schemaKey) {
     return "unknown";
   }
-  const mappedInContentConfig = await readCollectionTypeBySchemaFromContentConfig();
-  const map = {
-    ...mappedInContentConfig,
-    ...collectionTypeBySchemaFromConfig
-  };
+  const map = await readCollectionTypeBySchema();
   const normalizedSchemaKey = schemaKey.trim();
   const collectionType = normalizeSchemaKey(normalizedSchemaKey).map((key) => map[key]).find((value) => value === "page" || value === "data");
   return collectionType ?? "unknown";

package/dist/runtime/server/utils/schemaColumns.js

@@ -66,8 +66,11 @@ function collectSchemaColumns(schema, prefix = "") {
     const arrayPrefix = `${prefix}[0]`;
     const elementCandidate = getDefValue(unwrapped, "element");
     const arrayElement = isZodType(elementCandidate) ? elementCandidate : null;
-    const nested = arrayElement ? collectSchemaColumns(arrayElement, arrayPrefix) : [];
-    return nested.length ? nested : [arrayPrefix];
+    if (arrayElement && getObjectShape(arrayElement)) {
+      const nested = collectSchemaColumns(arrayElement, arrayPrefix);
+      return nested.length ? nested : [arrayPrefix];
+    }
+    return prefix ? [prefix] : [arrayPrefix];
   }
   const objectShape = getObjectShape(unwrapped);
   if (objectShape) {

package/dist/runtime/server/utils/transform.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { parseHeaderPath, setDeep } from "../../utils/pathMapping.js";
 function isZodType(value) {
   return typeof value === "object" && value !== null && "_def" in value;
 }
@@ -47,48 +48,6 @@ function hasWrapper(schema, wrapper) {
   }
   return false;
 }
-function parseHeaderPath(header) {
-  const tokens = [];
-  const parts = header.split(".");
-  for (const part of parts) {
-    const matches = part.matchAll(/([^[]+)|(\[(\d+)\])/g);
-    for (const match of matches) {
-      if (match[1]) {
-        tokens.push(match[1]);
-      }
-      if (match[3]) {
-        tokens.push(Number.parseInt(match[3], 10));
-      }
-    }
-  }
-  return tokens;
-}
-function setDeep(target, path, value) {
-  if (!path.length) {
-    return;
-  }
-  let cursor = target;
-  for (let index = 0; index < path.length; index++) {
-    const key = path[index];
-    if (key === void 0) {
-      return;
-    }
-    const isLast = index === path.length - 1;
-    const nextKey = path[index + 1];
-    if (isLast) {
-      cursor[key] = value;
-      return;
-    }
-    if (cursor[key] === void 0) {
-      cursor[key] = typeof nextKey === "number" ? [] : {};
-    }
-    const nextCursor = cursor[key];
-    if (!nextCursor || typeof nextCursor !== "object") {
-      return;
-    }
-    cursor = nextCursor;
-  }
-}
 function getObjectShape(schema) {
   const unwrapped = unwrapSchema(schema);
   if (!unwrapped) {

package/dist/runtime/utils/clipboard.d.ts

@@ -0,0 +1,15 @@
+interface ToastLike {
+    add: (payload: {
+        title?: string;
+        description?: string;
+        color?: 'success' | 'error' | 'warning' | 'info' | 'neutral';
+    }) => void;
+}
+interface CopyTextWithToastOptions {
+    text: string;
+    toast: ToastLike;
+    description: string;
+    title?: string;
+}
+export declare function copyTextWithSuccessToast(options: CopyTextWithToastOptions): Promise<boolean>;
+export {};

package/dist/runtime/utils/clipboard.js

@@ -0,0 +1,12 @@
+export async function copyTextWithSuccessToast(options) {
+  if (!options.text) {
+    return false;
+  }
+  await navigator.clipboard.writeText(options.text);
+  options.toast.add({
+    title: options.title ?? "Copied",
+    description: options.description,
+    color: "success"
+  });
+  return true;
+}

package/dist/runtime/utils/delimited.d.ts

@@ -0,0 +1,2 @@
+export declare function toCsvRow(values: string[]): string;
+export declare function toTsvRow(values: string[]): string;

package/dist/runtime/utils/delimited.js

@@ -0,0 +1,9 @@
+export function toCsvRow(values) {
+  return values.map((value) => {
+    const escaped = value.replaceAll('"', '""');
+    return `"${escaped}"`;
+  }).join(",");
+}
+export function toTsvRow(values) {
+  return values.map((value) => value.replace(/[\t\r\n]+/g, " ")).join("	");
+}

package/dist/runtime/utils/pathMapping.d.ts

@@ -0,0 +1,4 @@
+export type PathSegment = string | number;
+export declare function parseHeaderPath(header: string): PathSegment[];
+export declare function setDeep(target: Record<string, unknown>, path: PathSegment[], value: unknown): void;
+export declare function flattenRecordToStringMap(record: Record<string, unknown>, prefix?: string): Map<string, string>;

package/dist/runtime/utils/pathMapping.js

@@ -0,0 +1,86 @@
+const EXCLUDED_EXPORT_PATHS = /* @__PURE__ */ new Set(["__hash__", "body"]);
+export function parseHeaderPath(header) {
+  const tokens = [];
+  const parts = header.split(".");
+  for (const part of parts) {
+    const matches = part.matchAll(/([^[]+)|(\[(\d+)\])/g);
+    for (const match of matches) {
+      if (match[1]) {
+        tokens.push(match[1]);
+      }
+      if (match[3]) {
+        tokens.push(Number.parseInt(match[3], 10));
+      }
+    }
+  }
+  return tokens;
+}
+export function setDeep(target, path, value) {
+  if (!path.length) {
+    return;
+  }
+  let cursor = target;
+  for (let index = 0; index < path.length; index++) {
+    const key = path[index];
+    if (key === void 0) {
+      return;
+    }
+    const isLast = index === path.length - 1;
+    const nextKey = path[index + 1];
+    if (isLast) {
+      cursor[key] = value;
+      return;
+    }
+    if (cursor[key] === void 0) {
+      cursor[key] = typeof nextKey === "number" ? [] : {};
+    }
+    const nextCursor = cursor[key];
+    if (!nextCursor || typeof nextCursor !== "object") {
+      return;
+    }
+    cursor = nextCursor;
+  }
+}
+export function flattenRecordToStringMap(record, prefix = "") {
+  const out = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(record)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (EXCLUDED_EXPORT_PATHS.has(path)) {
+      continue;
+    }
+    if (value === null || value === void 0) {
+      out.set(path, "");
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (value.every((item) => item === null || ["string", "number", "boolean"].includes(typeof item))) {
+        out.set(path, value.map((item) => item == null ? "" : String(item)).join(", "));
+        continue;
+      }
+      for (let index = 0; index < value.length; index++) {
+        const item = value[index];
+        const arrayPath = `${path}[${index}]`;
+        if (item && typeof item === "object" && !Array.isArray(item)) {
+          flattenRecordToStringMap(item, arrayPath).forEach((nestedValue, nestedKey) => {
+            out.set(nestedKey, nestedValue);
+          });
+        } else {
+          out.set(arrayPath, item == null ? "" : String(item));
+        }
+      }
+      continue;
+    }
+    if (value instanceof Date) {
+      out.set(path, value.toISOString());
+      continue;
+    }
+    if (typeof value === "object") {
+      flattenRecordToStringMap(value, path).forEach((nestedValue, nestedKey) => {
+        out.set(nestedKey, nestedValue);
+      });
+      continue;
+    }
+    out.set(path, String(value));
+  }
+  return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-google-sheets-import",
-  "version": "0.1.4",
+  "version": "0.1.7",
   "description": "Schema-driven Google Sheets import module for Nuxt Content",
   "repository": "tribeweb/nuxt-google-sheets-import",
   "license": "MIT",

package/dist/runtime/import/schemas.d.ts

@@ -1,67 +0,0 @@
-import { z } from 'zod';
-export declare const machinesSmoke: z.ZodObject<{
-    pageOrder: z.ZodNumber;
-    modelId: z.ZodString;
-    machineName: z.ZodString;
-    cutRate: z.ZodNumber;
-    featurePrimary: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const example: z.ZodObject<{
-    slug: z.ZodString;
-    pageOrder: z.ZodCoercedNumber<unknown>;
-    number: z.ZodCoercedNumber<unknown>;
-    string: z.ZodString;
-    enumString: z.ZodEnum<{
-        foo: "foo";
-        bar: "bar";
-        baz: "baz";
-    }>;
-    literalString: z.ZodLiteral<"foo">;
-    unionString: z.ZodUnion<readonly [z.ZodLiteral<"foo">, z.ZodLiteral<"bar">]>;
-    unionStringArray: z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<"foo">, z.ZodLiteral<"bar">]>>;
-    exclusiveUnionString: z.ZodXor<readonly [z.ZodLiteral<"foo">, z.ZodLiteral<"bar">]>;
-    stringArray: z.ZodArray<z.ZodString>;
-    boolean: z.ZodCoercedBoolean<unknown>;
-    object: z.ZodObject<{
-        key1: z.ZodString;
-        key2: z.ZodString;
-    }, z.core.$strip>;
-    objectArray: z.ZodArray<z.ZodObject<{
-        keyA: z.ZodString;
-        keyB: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const schemas: {
-    machinesSmoke: z.ZodObject<{
-        pageOrder: z.ZodNumber;
-        modelId: z.ZodString;
-        machineName: z.ZodString;
-        cutRate: z.ZodNumber;
-        featurePrimary: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-    example: z.ZodObject<{
-        slug: z.ZodString;
-        pageOrder: z.ZodCoercedNumber<unknown>;
-        number: z.ZodCoercedNumber<unknown>;
-        string: z.ZodString;
-        enumString: z.ZodEnum<{
-            foo: "foo";
-            bar: "bar";
-            baz: "baz";
-        }>;
-        literalString: z.ZodLiteral<"foo">;
-        unionString: z.ZodUnion<readonly [z.ZodLiteral<"foo">, z.ZodLiteral<"bar">]>;
-        unionStringArray: z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<"foo">, z.ZodLiteral<"bar">]>>;
-        exclusiveUnionString: z.ZodXor<readonly [z.ZodLiteral<"foo">, z.ZodLiteral<"bar">]>;
-        stringArray: z.ZodArray<z.ZodString>;
-        boolean: z.ZodCoercedBoolean<unknown>;
-        object: z.ZodObject<{
-            key1: z.ZodString;
-            key2: z.ZodString;
-        }, z.core.$strip>;
-        objectArray: z.ZodArray<z.ZodObject<{
-            keyA: z.ZodString;
-            keyB: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-};