office-open 0.0.0 → 0.6.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Demo Macro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/ai/index.d.mts

@@ -0,0 +1,222 @@
+//#region src/ai/index.d.ts
+declare const docxTool: import("ai").Tool<{
+  [x: string]: unknown;
+  sections: {
+    [x: string]: unknown;
+    children: (string | Record<string, unknown>)[];
+    properties?: Record<string, unknown> | undefined;
+    headers?: Record<string, unknown> | undefined;
+    footers?: Record<string, unknown> | undefined;
+  }[];
+  title?: string | undefined;
+  subject?: string | undefined;
+  creator?: string | undefined;
+  keywords?: string | undefined;
+  description?: string | undefined;
+  lastModifiedBy?: string | undefined;
+  revision?: number | undefined;
+  externalStyles?: string | undefined;
+  styles?: Record<string, unknown> | undefined;
+  numbering?: Record<string, unknown> | undefined;
+  comments?: Record<string, unknown> | undefined;
+  bibliography?: Record<string, unknown> | undefined;
+  footnotes?: Record<string, Record<string, unknown>> | undefined;
+  endnotes?: Record<string, Record<string, unknown>> | undefined;
+  background?: Record<string, unknown> | undefined;
+  features?: Record<string, unknown> | undefined;
+  compatabilityModeVersion?: number | undefined;
+  compatibility?: Record<string, unknown> | undefined;
+  customProperties?: Record<string, unknown>[] | undefined;
+  evenAndOddHeaderAndFooters?: boolean | undefined;
+  defaultTabStop?: number | undefined;
+  fonts?: Record<string, unknown>[] | undefined;
+  hyphenation?: Record<string, unknown> | undefined;
+  characterSpacingControl?: string | undefined;
+  view?: string | undefined;
+  zoom?: Record<string, unknown> | undefined;
+  writeProtection?: Record<string, unknown> | undefined;
+  displayBackgroundShape?: boolean | undefined;
+  embedTrueTypeFonts?: boolean | undefined;
+  embedSystemFonts?: boolean | undefined;
+  saveSubsetFonts?: boolean | undefined;
+  docVars?: Record<string, unknown>[] | undefined;
+  colorSchemeMapping?: unknown;
+}, {
+  base64: string;
+  mimeType: string;
+}>;
+declare const pptxTool: import("ai").Tool<{
+  [x: string]: unknown;
+  slides: {
+    [x: string]: unknown;
+    children: (string | Record<string, unknown>)[];
+    background?: Record<string, unknown> | undefined;
+    transition?: Record<string, unknown> | undefined;
+    notes?: string | undefined;
+    layout?: string | undefined;
+    master?: string | undefined;
+    comments?: Record<string, unknown>[] | undefined;
+    headerFooter?: Record<string, unknown> | undefined;
+  }[];
+  size?: "16:9" | "4:3" | {
+    width: number;
+    height: number;
+  } | undefined;
+  masters?: Record<string, unknown>[] | undefined;
+  show?: Record<string, unknown> | undefined;
+  title?: string | undefined;
+  subject?: string | undefined;
+  creator?: string | undefined;
+  keywords?: string | undefined;
+  description?: string | undefined;
+  lastModifiedBy?: string | undefined;
+  revision?: number | undefined;
+}, {
+  base64: string;
+  mimeType: string;
+}>;
+declare const xlsxTool: import("ai").Tool<{
+  [x: string]: unknown;
+  worksheets: {
+    [x: string]: unknown;
+    name?: string | undefined;
+    children?: {
+      [x: string]: unknown;
+      cells?: (string | number | boolean | Record<string, unknown>)[] | undefined;
+      height?: number | undefined;
+      hidden?: boolean | undefined;
+      rowNumber?: number | undefined;
+    }[] | undefined;
+    columns?: Record<string, unknown>[] | undefined;
+    mergeCells?: Record<string, unknown>[] | undefined;
+    freezePanes?: Record<string, unknown> | undefined;
+    autoFilter?: string | undefined;
+    images?: Record<string, unknown>[] | undefined;
+    charts?: Record<string, unknown>[] | undefined;
+    dataValidations?: Record<string, unknown>[] | undefined;
+    conditionalFormats?: Record<string, unknown>[] | undefined;
+  }[];
+  title?: string | undefined;
+  subject?: string | undefined;
+  creator?: string | undefined;
+  keywords?: string | undefined;
+  description?: string | undefined;
+  lastModifiedBy?: string | undefined;
+  revision?: number | undefined;
+}, {
+  base64: string;
+  mimeType: string;
+}>;
+declare const officeOpenTools: {
+  readonly "generate-docx": import("ai").Tool<{
+    [x: string]: unknown;
+    sections: {
+      [x: string]: unknown;
+      children: (string | Record<string, unknown>)[];
+      properties?: Record<string, unknown> | undefined;
+      headers?: Record<string, unknown> | undefined;
+      footers?: Record<string, unknown> | undefined;
+    }[];
+    title?: string | undefined;
+    subject?: string | undefined;
+    creator?: string | undefined;
+    keywords?: string | undefined;
+    description?: string | undefined;
+    lastModifiedBy?: string | undefined;
+    revision?: number | undefined;
+    externalStyles?: string | undefined;
+    styles?: Record<string, unknown> | undefined;
+    numbering?: Record<string, unknown> | undefined;
+    comments?: Record<string, unknown> | undefined;
+    bibliography?: Record<string, unknown> | undefined;
+    footnotes?: Record<string, Record<string, unknown>> | undefined;
+    endnotes?: Record<string, Record<string, unknown>> | undefined;
+    background?: Record<string, unknown> | undefined;
+    features?: Record<string, unknown> | undefined;
+    compatabilityModeVersion?: number | undefined;
+    compatibility?: Record<string, unknown> | undefined;
+    customProperties?: Record<string, unknown>[] | undefined;
+    evenAndOddHeaderAndFooters?: boolean | undefined;
+    defaultTabStop?: number | undefined;
+    fonts?: Record<string, unknown>[] | undefined;
+    hyphenation?: Record<string, unknown> | undefined;
+    characterSpacingControl?: string | undefined;
+    view?: string | undefined;
+    zoom?: Record<string, unknown> | undefined;
+    writeProtection?: Record<string, unknown> | undefined;
+    displayBackgroundShape?: boolean | undefined;
+    embedTrueTypeFonts?: boolean | undefined;
+    embedSystemFonts?: boolean | undefined;
+    saveSubsetFonts?: boolean | undefined;
+    docVars?: Record<string, unknown>[] | undefined;
+    colorSchemeMapping?: unknown;
+  }, {
+    base64: string;
+    mimeType: string;
+  }>;
+  readonly "generate-pptx": import("ai").Tool<{
+    [x: string]: unknown;
+    slides: {
+      [x: string]: unknown;
+      children: (string | Record<string, unknown>)[];
+      background?: Record<string, unknown> | undefined;
+      transition?: Record<string, unknown> | undefined;
+      notes?: string | undefined;
+      layout?: string | undefined;
+      master?: string | undefined;
+      comments?: Record<string, unknown>[] | undefined;
+      headerFooter?: Record<string, unknown> | undefined;
+    }[];
+    size?: "16:9" | "4:3" | {
+      width: number;
+      height: number;
+    } | undefined;
+    masters?: Record<string, unknown>[] | undefined;
+    show?: Record<string, unknown> | undefined;
+    title?: string | undefined;
+    subject?: string | undefined;
+    creator?: string | undefined;
+    keywords?: string | undefined;
+    description?: string | undefined;
+    lastModifiedBy?: string | undefined;
+    revision?: number | undefined;
+  }, {
+    base64: string;
+    mimeType: string;
+  }>;
+  readonly "generate-xlsx": import("ai").Tool<{
+    [x: string]: unknown;
+    worksheets: {
+      [x: string]: unknown;
+      name?: string | undefined;
+      children?: {
+        [x: string]: unknown;
+        cells?: (string | number | boolean | Record<string, unknown>)[] | undefined;
+        height?: number | undefined;
+        hidden?: boolean | undefined;
+        rowNumber?: number | undefined;
+      }[] | undefined;
+      columns?: Record<string, unknown>[] | undefined;
+      mergeCells?: Record<string, unknown>[] | undefined;
+      freezePanes?: Record<string, unknown> | undefined;
+      autoFilter?: string | undefined;
+      images?: Record<string, unknown>[] | undefined;
+      charts?: Record<string, unknown>[] | undefined;
+      dataValidations?: Record<string, unknown>[] | undefined;
+      conditionalFormats?: Record<string, unknown>[] | undefined;
+    }[];
+    title?: string | undefined;
+    subject?: string | undefined;
+    creator?: string | undefined;
+    keywords?: string | undefined;
+    description?: string | undefined;
+    lastModifiedBy?: string | undefined;
+    revision?: number | undefined;
+  }, {
+    base64: string;
+    mimeType: string;
+  }>;
+};
+//#endregion
+export { docxTool, officeOpenTools, pptxTool, xlsxTool };
+//# sourceMappingURL=index.d.mts.map

package/dist/ai/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/ai/index.ts"],"mappings":";cAQa,QAAA,eAAQ,IAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsBR,QAAA,eAAQ,IAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsBR,QAAA,eAAQ,IAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsBR,eAAA;EAAA"}

package/dist/ai/index.mjs

@@ -0,0 +1,55 @@
+import { generate } from "../generate.mjs";
+import { a as docxSchema, i as pptxSchema, n as validateDocumentInput, r as xlsxSchema } from "../schemas-BbRmv4RW.mjs";
+import { tool } from "ai";
+//#region src/ai/index.ts
+const docxTool = tool({
+	description: "Generate a .docx Word document. The input is the document options directly — must include a 'sections' array. Each section has 'children' (paragraphs, tables, etc.). Paragraphs use { paragraph: { children: [{ text: '...' }] }}, tables use { table: { rows: [...] } }. Optional metadata: title, creator, subject, styles, numbering, comments, footnotes, endnotes, background, features.",
+	inputSchema: docxSchema,
+	execute: async (options) => {
+		return {
+			base64: await generate({
+				type: "docx",
+				options: validateDocumentInput("docx", options),
+				outputType: "base64"
+			}),
+			mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+		};
+	}
+});
+const pptxTool = tool({
+	description: "Generate a .pptx PowerPoint presentation. The input is the document options directly — must include a 'slides' array. Each slide has 'children' (shapes, pictures, tables, charts, groups, etc.). Shapes use { shape: { x, y, width, height, text?, fill?, ... } }. Optional: size ('16:9' or '4:3' or { width, height }), title, creator, masters, show.",
+	inputSchema: pptxSchema,
+	execute: async (options) => {
+		return {
+			base64: await generate({
+				type: "pptx",
+				options: validateDocumentInput("pptx", options),
+				outputType: "base64"
+			}),
+			mimeType: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+		};
+	}
+});
+const xlsxTool = tool({
+	description: "Generate a .xlsx Excel spreadsheet. The input is the document options directly — must include a 'worksheets' array. Each worksheet has 'children' (NOT 'rows') — an array of row objects, each with 'cells'. Cell values: string, number, boolean. Use 'style' for formatting. Optional: columns, mergeCells, freezePanes, autoFilter, images, charts, dataValidations, conditionalFormats.",
+	inputSchema: xlsxSchema,
+	execute: async (options) => {
+		return {
+			base64: await generate({
+				type: "xlsx",
+				options: validateDocumentInput("xlsx", options),
+				outputType: "base64"
+			}),
+			mimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+		};
+	}
+});
+const officeOpenTools = {
+	"generate-docx": docxTool,
+	"generate-pptx": pptxTool,
+	"generate-xlsx": xlsxTool
+};
+//#endregion
+export { docxTool, officeOpenTools, pptxTool, xlsxTool };
+
+//# sourceMappingURL=index.mjs.map

package/dist/ai/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/ai/index.ts"],"sourcesContent":["import { tool } from \"ai\";\n\nimport { generate } from \"../generate\";\nimport { validateDocumentInput } from \"../schemas\";\nimport { docxSchema } from \"../schemas/docx\";\nimport { pptxSchema } from \"../schemas/pptx\";\nimport { xlsxSchema } from \"../schemas/xlsx\";\n\nexport const docxTool = tool({\n  description:\n    \"Generate a .docx Word document. \" +\n    \"The input is the document options directly — must include a 'sections' array. \" +\n    \"Each section has 'children' (paragraphs, tables, etc.). \" +\n    \"Paragraphs use { paragraph: { children: [{ text: '...' }] }}, tables use { table: { rows: [...] } }. \" +\n    \"Optional metadata: title, creator, subject, styles, numbering, comments, footnotes, endnotes, background, features.\",\n  inputSchema: docxSchema,\n  execute: async (options) => {\n    const validated = validateDocumentInput(\"docx\", options);\n    const base64 = (await generate({\n      type: \"docx\",\n      options: validated,\n      outputType: \"base64\",\n    })) as string;\n    return {\n      base64,\n      mimeType: \"application/vnd.openxmlformats-officedocument.wordprocessingml.document\",\n    };\n  },\n});\n\nexport const pptxTool = tool({\n  description:\n    \"Generate a .pptx PowerPoint presentation. \" +\n    \"The input is the document options directly — must include a 'slides' array. \" +\n    \"Each slide has 'children' (shapes, pictures, tables, charts, groups, etc.). \" +\n    \"Shapes use { shape: { x, y, width, height, text?, fill?, ... } }. \" +\n    \"Optional: size ('16:9' or '4:3' or { width, height }), title, creator, masters, show.\",\n  inputSchema: pptxSchema,\n  execute: async (options) => {\n    const validated = validateDocumentInput(\"pptx\", options);\n    const base64 = (await generate({\n      type: \"pptx\",\n      options: validated,\n      outputType: \"base64\",\n    })) as string;\n    return {\n      base64,\n      mimeType: \"application/vnd.openxmlformats-officedocument.presentationml.presentation\",\n    };\n  },\n});\n\nexport const xlsxTool = tool({\n  description:\n    \"Generate a .xlsx Excel spreadsheet. \" +\n    \"The input is the document options directly — must include a 'worksheets' array. \" +\n    \"Each worksheet has 'children' (NOT 'rows') — an array of row objects, each with 'cells'. \" +\n    \"Cell values: string, number, boolean. Use 'style' for formatting. \" +\n    \"Optional: columns, mergeCells, freezePanes, autoFilter, images, charts, dataValidations, conditionalFormats.\",\n  inputSchema: xlsxSchema,\n  execute: async (options) => {\n    const validated = validateDocumentInput(\"xlsx\", options);\n    const base64 = (await generate({\n      type: \"xlsx\",\n      options: validated,\n      outputType: \"base64\",\n    })) as string;\n    return {\n      base64,\n      mimeType: \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet\",\n    };\n  },\n});\n\nexport const officeOpenTools = {\n  \"generate-docx\": docxTool,\n  \"generate-pptx\": pptxTool,\n  \"generate-xlsx\": xlsxTool,\n} as const;\n"],"mappings":";;;;AAQA,MAAa,WAAW,KAAK;CAC3B,aACE;CAKF,aAAa;CACb,SAAS,OAAO,YAAY;EAO1B,OAAO;GACL,QAAA,MANoB,SAAS;IAC7B,MAAM;IACN,SAHgB,sBAAsB,QAAQ,OAG7B;IACjB,YAAY;GACd,CAAC;GAGC,UAAU;EACZ;CACF;AACF,CAAC;AAED,MAAa,WAAW,KAAK;CAC3B,aACE;CAKF,aAAa;CACb,SAAS,OAAO,YAAY;EAO1B,OAAO;GACL,QAAA,MANoB,SAAS;IAC7B,MAAM;IACN,SAHgB,sBAAsB,QAAQ,OAG7B;IACjB,YAAY;GACd,CAAC;GAGC,UAAU;EACZ;CACF;AACF,CAAC;AAED,MAAa,WAAW,KAAK;CAC3B,aACE;CAKF,aAAa;CACb,SAAS,OAAO,YAAY;EAO1B,OAAO;GACL,QAAA,MANoB,SAAS;IAC7B,MAAM;IACN,SAHgB,sBAAsB,QAAQ,OAG7B;IACjB,YAAY;GACd,CAAC;GAGC,UAAU;EACZ;CACF;AACF,CAAC;AAED,MAAa,kBAAkB;CAC7B,iBAAiB;CACjB,iBAAiB;CACjB,iBAAiB;AACnB"}

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,70 @@
+import { generateToFile, parseInput } from "./generate.mjs";
+import { n as validateDocumentInput } from "./schemas-BbRmv4RW.mjs";
+import { defineCommand, runMain } from "citty";
+//#region src/cli.ts
+function createConvertCommand(type, defaultExt) {
+	return defineCommand({
+		meta: {
+			name: type,
+			description: `Generate a .${defaultExt} file from JSON`
+		},
+		args: {
+			input: {
+				type: "positional",
+				description: "JSON string or path to JSON file",
+				required: true
+			},
+			output: {
+				type: "positional",
+				description: `Output file path (default: output.${defaultExt})`,
+				required: false
+			},
+			"input-file": {
+				type: "string",
+				description: "Read JSON from file (alternative to positional input)",
+				alias: ["i"]
+			},
+			"output-file": {
+				type: "string",
+				description: "Output file path (alternative to positional output)",
+				alias: ["o"]
+			}
+		},
+		async run({ args }) {
+			const jsonInput = args.input ?? args["input-file"];
+			const outputPath = args.output ?? args["output-file"] ?? `output.${defaultExt}`;
+			const docType = type;
+			await generateToFile(outputPath, {
+				type: docType,
+				options: validateDocumentInput(docType, await parseInput(jsonInput))
+			});
+			console.log(`Generated: ${outputPath}`);
+		}
+	});
+}
+runMain(defineCommand({
+	meta: {
+		name: "office-open",
+		version: "0.6.8",
+		description: "Generate Office files (.docx, .pptx, .xlsx) from JSON"
+	},
+	subCommands: {
+		docx: createConvertCommand("docx", "docx"),
+		pptx: createConvertCommand("pptx", "pptx"),
+		xlsx: createConvertCommand("xlsx", "xlsx")
+	},
+	args: { type: {
+		type: "enum",
+		description: "File type to generate",
+		options: [
+			"docx",
+			"pptx",
+			"xlsx"
+		]
+	} },
+	async run() {}
+}));
+//#endregion
+export {};
+
+//# sourceMappingURL=cli.mjs.map

package/dist/cli.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.mjs","names":[],"sources":["../src/cli.ts"],"sourcesContent":["import { defineCommand, runMain } from \"citty\";\n\nimport { generateToFile, parseInput } from \"./generate\";\nimport { validateDocumentInput } from \"./schemas\";\n\nfunction createConvertCommand(type: string, defaultExt: string) {\n  return defineCommand({\n    meta: {\n      name: type,\n      description: `Generate a .${defaultExt} file from JSON`,\n    },\n    args: {\n      input: {\n        type: \"positional\",\n        description: \"JSON string or path to JSON file\",\n        required: true,\n      },\n      output: {\n        type: \"positional\",\n        description: `Output file path (default: output.${defaultExt})`,\n        required: false,\n      },\n      \"input-file\": {\n        type: \"string\",\n        description: \"Read JSON from file (alternative to positional input)\",\n        alias: [\"i\"],\n      },\n      \"output-file\": {\n        type: \"string\",\n        description: \"Output file path (alternative to positional output)\",\n        alias: [\"o\"],\n      },\n    },\n    async run({ args }) {\n      const jsonInput = (args.input ?? args[\"input-file\"]) as string;\n      const outputPath = (args.output ?? args[\"output-file\"] ?? `output.${defaultExt}`) as string;\n      const docType = type as \"docx\" | \"pptx\" | \"xlsx\";\n\n      const docOptions = await parseInput(jsonInput);\n      const validated = validateDocumentInput(docType, docOptions);\n      await generateToFile(outputPath, {\n        type: docType,\n        options: validated,\n      });\n      console.log(`Generated: ${outputPath}`);\n    },\n  });\n}\n\nconst mainCommand = defineCommand({\n  meta: {\n    name: \"office-open\",\n    version: \"0.6.8\",\n    description: \"Generate Office files (.docx, .pptx, .xlsx) from JSON\",\n  },\n  subCommands: {\n    docx: createConvertCommand(\"docx\", \"docx\"),\n    pptx: createConvertCommand(\"pptx\", \"pptx\"),\n    xlsx: createConvertCommand(\"xlsx\", \"xlsx\"),\n  },\n  args: {\n    type: {\n      type: \"enum\",\n      description: \"File type to generate\",\n      options: [\"docx\", \"pptx\", \"xlsx\"],\n    },\n  },\n  async run() {\n    // citty shows usage when no subcommand is matched\n  },\n});\n\nvoid runMain(mainCommand);\n"],"mappings":";;;;AAKA,SAAS,qBAAqB,MAAc,YAAoB;CAC9D,OAAO,cAAc;EACnB,MAAM;GACJ,MAAM;GACN,aAAa,eAAe,WAAW;EACzC;EACA,MAAM;GACJ,OAAO;IACL,MAAM;IACN,aAAa;IACb,UAAU;GACZ;GACA,QAAQ;IACN,MAAM;IACN,aAAa,qCAAqC,WAAW;IAC7D,UAAU;GACZ;GACA,cAAc;IACZ,MAAM;IACN,aAAa;IACb,OAAO,CAAC,GAAG;GACb;GACA,eAAe;IACb,MAAM;IACN,aAAa;IACb,OAAO,CAAC,GAAG;GACb;EACF;EACA,MAAM,IAAI,EAAE,QAAQ;GAClB,MAAM,YAAa,KAAK,SAAS,KAAK;GACtC,MAAM,aAAc,KAAK,UAAU,KAAK,kBAAkB,UAAU;GACpE,MAAM,UAAU;GAIhB,MAAM,eAAe,YAAY;IAC/B,MAAM;IACN,SAHgB,sBAAsB,SAAS,MADxB,WAAW,SAAS,CAI1B;GACnB,CAAC;GACD,QAAQ,IAAI,cAAc,YAAY;EACxC;CACF,CAAC;AACH;AAyBK,QAvBe,cAAc;CAChC,MAAM;EACJ,MAAM;EACN,SAAS;EACT,aAAa;CACf;CACA,aAAa;EACX,MAAM,qBAAqB,QAAQ,MAAM;EACzC,MAAM,qBAAqB,QAAQ,MAAM;EACzC,MAAM,qBAAqB,QAAQ,MAAM;CAC3C;CACA,MAAM,EACJ,MAAM;EACJ,MAAM;EACN,aAAa;EACb,SAAS;GAAC;GAAQ;GAAQ;EAAM;CAClC,EACF;CACA,MAAM,MAAM,CAEZ;AACF,CAEuB,CAAC"}

package/dist/core.d.mts

@@ -0,0 +1 @@
+export * from "@office-open/core";

package/dist/core.mjs

@@ -0,0 +1,2 @@
+export * from "@office-open/core";
+export {};

package/dist/docx.d.mts

@@ -0,0 +1 @@
+export * from "@office-open/docx";

package/dist/docx.mjs

@@ -0,0 +1,2 @@
+export * from "@office-open/docx";
+export {};

package/dist/generate.d.mts

@@ -0,0 +1,15 @@
+import { OutputType, OutputType as OutputType$1 } from "@office-open/core";
+
+//#region src/generate.d.ts
+type GenerateType = "docx" | "pptx" | "xlsx";
+interface GenerateOptions {
+  readonly type: GenerateType;
+  readonly options: Record<string, unknown>;
+  readonly outputType?: OutputType$1;
+}
+declare function generate(options: GenerateOptions): Promise<unknown>;
+declare function parseInput(input: string): Promise<Record<string, unknown>>;
+declare function generateToFile(outputPath: string, options: GenerateOptions): Promise<void>;
+//#endregion
+export { GenerateOptions, GenerateType, type OutputType, generate, generateToFile, parseInput };
+//# sourceMappingURL=generate.d.mts.map

package/dist/generate.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.mts","names":[],"sources":["../src/generate.ts"],"mappings":";;;KAYY,YAAA;AAAA,UAEK,eAAA;EAAA,SACN,IAAA,EAAM,YAAA;EAAA,SACN,OAAA,EAAS,MAAA;EAAA,SACT,UAAA,GAAa,YAAA;AAAA;AAAA,iBAwBF,QAAA,CAAS,OAAA,EAAS,eAAA,GAAkB,OAAO;AAAA,iBAO3C,UAAA,CAAW,KAAA,WAAgB,OAAO,CAAC,MAAA;AAAA,iBASnC,cAAA,CAAe,UAAA,UAAoB,OAAA,EAAS,eAAA,GAAkB,OAAO"}

package/dist/generate.mjs

@@ -0,0 +1,40 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { Document, Packer } from "@office-open/docx";
+import { Packer as Packer$1, Presentation } from "@office-open/pptx";
+import { Packer as Packer$2, Workbook } from "@office-open/xlsx";
+//#region src/generate.ts
+const PACKERS = {
+	docx: {
+		newFile: (opts) => new Document(opts),
+		pack: (file, type) => Packer.pack(file, type)
+	},
+	pptx: {
+		newFile: (opts) => new Presentation(opts),
+		pack: (file, type) => Packer$1.pack(file, type)
+	},
+	xlsx: {
+		newFile: (opts) => new Workbook(opts),
+		pack: (file, type) => Packer$2.pack(file, type)
+	}
+};
+async function generate(options) {
+	const { type, options: docOptions, outputType = "nodebuffer" } = options;
+	const { newFile, pack } = PACKERS[type];
+	return pack(newFile(docOptions), outputType);
+}
+async function parseInput(input) {
+	const trimmed = input.trim();
+	if (trimmed.startsWith("{") || trimmed.startsWith("[")) return JSON.parse(trimmed);
+	const content = await readFile(trimmed, "utf-8");
+	return JSON.parse(content);
+}
+async function generateToFile(outputPath, options) {
+	await writeFile(outputPath, await generate({
+		...options,
+		outputType: "nodebuffer"
+	}));
+}
+//#endregion
+export { generate, generateToFile, parseInput };
+
+//# sourceMappingURL=generate.mjs.map

package/dist/generate.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.mjs","names":["DocxPacker","PptxPacker","XlsxPacker"],"sources":["../src/generate.ts"],"sourcesContent":["import { readFile, writeFile } from \"node:fs/promises\";\n\nimport type { OutputType } from \"@office-open/core\";\nexport { type OutputType } from \"@office-open/core\";\n\nimport { Document, Packer as DocxPacker } from \"@office-open/docx\";\nimport type { PropertiesOptions } from \"@office-open/docx\";\nimport { Presentation, Packer as PptxPacker } from \"@office-open/pptx\";\nimport type { PresentationOptions } from \"@office-open/pptx\";\nimport { Workbook, Packer as XlsxPacker } from \"@office-open/xlsx\";\nimport type { WorkbookOptions } from \"@office-open/xlsx\";\n\nexport type GenerateType = \"docx\" | \"pptx\" | \"xlsx\";\n\nexport interface GenerateOptions {\n  readonly type: GenerateType;\n  readonly options: Record<string, unknown>;\n  readonly outputType?: OutputType;\n}\n\nconst PACKERS = {\n  docx: {\n    newFile: (opts: unknown) => new Document(opts as unknown as PropertiesOptions),\n    pack: (file: unknown, type: OutputType) => DocxPacker.pack(file as Document, type),\n  },\n  pptx: {\n    newFile: (opts: unknown) => new Presentation(opts as unknown as PresentationOptions),\n    pack: (file: unknown, type: OutputType) => PptxPacker.pack(file as Presentation, type),\n  },\n  xlsx: {\n    newFile: (opts: unknown) => new Workbook(opts as unknown as WorkbookOptions),\n    pack: (file: unknown, type: OutputType) => XlsxPacker.pack(file as Workbook, type),\n  },\n} as const satisfies Record<\n  GenerateType,\n  {\n    newFile: (opts: unknown) => unknown;\n    pack: (file: unknown, type: OutputType) => Promise<unknown>;\n  }\n>;\n\nexport async function generate(options: GenerateOptions): Promise<unknown> {\n  const { type, options: docOptions, outputType = \"nodebuffer\" as OutputType } = options;\n  const { newFile, pack } = PACKERS[type];\n  const file = newFile(docOptions);\n  return pack(file, outputType);\n}\n\nexport async function parseInput(input: string): Promise<Record<string, unknown>> {\n  const trimmed = input.trim();\n  if (trimmed.startsWith(\"{\") || trimmed.startsWith(\"[\")) {\n    return JSON.parse(trimmed) as Record<string, unknown>;\n  }\n  const content = await readFile(trimmed, \"utf-8\");\n  return JSON.parse(content) as Record<string, unknown>;\n}\n\nexport async function generateToFile(outputPath: string, options: GenerateOptions): Promise<void> {\n  const buffer = (await generate({ ...options, outputType: \"nodebuffer\" })) as Buffer;\n  await writeFile(outputPath, buffer);\n}\n"],"mappings":";;;;;AAoBA,MAAM,UAAU;CACd,MAAM;EACJ,UAAU,SAAkB,IAAI,SAAS,IAAoC;EAC7E,OAAO,MAAe,SAAqBA,OAAW,KAAK,MAAkB,IAAI;CACnF;CACA,MAAM;EACJ,UAAU,SAAkB,IAAI,aAAa,IAAsC;EACnF,OAAO,MAAe,SAAqBC,SAAW,KAAK,MAAsB,IAAI;CACvF;CACA,MAAM;EACJ,UAAU,SAAkB,IAAI,SAAS,IAAkC;EAC3E,OAAO,MAAe,SAAqBC,SAAW,KAAK,MAAkB,IAAI;CACnF;AACF;AAQA,eAAsB,SAAS,SAA4C;CACzE,MAAM,EAAE,MAAM,SAAS,YAAY,aAAa,iBAA+B;CAC/E,MAAM,EAAE,SAAS,SAAS,QAAQ;CAElC,OAAO,KADM,QAAQ,UACN,GAAG,UAAU;AAC9B;AAEA,eAAsB,WAAW,OAAiD;CAChF,MAAM,UAAU,MAAM,KAAK;CAC3B,IAAI,QAAQ,WAAW,GAAG,KAAK,QAAQ,WAAW,GAAG,GACnD,OAAO,KAAK,MAAM,OAAO;CAE3B,MAAM,UAAU,MAAM,SAAS,SAAS,OAAO;CAC/C,OAAO,KAAK,MAAM,OAAO;AAC3B;AAEA,eAAsB,eAAe,YAAoB,SAAyC;CAEhG,MAAM,UAAU,YAAY,MADN,SAAS;EAAE,GAAG;EAAS,YAAY;CAAa,CAAC,CACrC;AACpC"}

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+import { GenerateOptions, GenerateType, OutputType, generate, generateToFile, parseInput } from "./generate.mjs";
+export { type GenerateOptions, type GenerateType, type OutputType, generate, generateToFile, parseInput };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { generate, generateToFile, parseInput } from "./generate.mjs";
+export { generate, generateToFile, parseInput };

package/dist/pptx.d.mts

@@ -0,0 +1 @@
+export * from "@office-open/pptx";

package/dist/pptx.mjs

@@ -0,0 +1,2 @@
+export * from "@office-open/pptx";
+export {};

package/dist/schemas/index.d.mts

@@ -0,0 +1,206 @@
+import { z } from "zod";
+
+//#region src/schemas/docx.d.ts
+declare const docxSchema: z.ZodObject<{
+  sections: z.ZodArray<z.ZodObject<{
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    children: z.ZodArray<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    footers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$loose>>;
+  title: z.ZodOptional<z.ZodString>;
+  subject: z.ZodOptional<z.ZodString>;
+  creator: z.ZodOptional<z.ZodString>;
+  keywords: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+  lastModifiedBy: z.ZodOptional<z.ZodString>;
+  revision: z.ZodOptional<z.ZodNumber>;
+  externalStyles: z.ZodOptional<z.ZodString>;
+  styles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  numbering: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  comments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  bibliography: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  footnotes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  endnotes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  background: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  features: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  compatabilityModeVersion: z.ZodOptional<z.ZodNumber>;
+  compatibility: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  customProperties: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  evenAndOddHeaderAndFooters: z.ZodOptional<z.ZodBoolean>;
+  defaultTabStop: z.ZodOptional<z.ZodNumber>;
+  fonts: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  hyphenation: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  characterSpacingControl: z.ZodOptional<z.ZodString>;
+  view: z.ZodOptional<z.ZodString>;
+  zoom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  writeProtection: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  displayBackgroundShape: z.ZodOptional<z.ZodBoolean>;
+  embedTrueTypeFonts: z.ZodOptional<z.ZodBoolean>;
+  embedSystemFonts: z.ZodOptional<z.ZodBoolean>;
+  saveSubsetFonts: z.ZodOptional<z.ZodBoolean>;
+  docVars: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  colorSchemeMapping: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>;
+//#endregion
+//#region src/schemas/pptx.d.ts
+declare const pptxSchema: z.ZodObject<{
+  slides: z.ZodArray<z.ZodObject<{
+    children: z.ZodArray<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
+    background: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    transition: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    notes: z.ZodOptional<z.ZodString>;
+    layout: z.ZodOptional<z.ZodString>;
+    master: z.ZodOptional<z.ZodString>;
+    comments: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    headerFooter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$loose>>;
+  size: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+    "16:9": "16:9";
+    "4:3": "4:3";
+  }>, z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+  }, z.core.$strip>]>>;
+  masters: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  show: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  title: z.ZodOptional<z.ZodString>;
+  subject: z.ZodOptional<z.ZodString>;
+  creator: z.ZodOptional<z.ZodString>;
+  keywords: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+  lastModifiedBy: z.ZodOptional<z.ZodString>;
+  revision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+//#endregion
+//#region src/schemas/xlsx.d.ts
+declare const xlsxSchema: z.ZodObject<{
+  worksheets: z.ZodArray<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    children: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      cells: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>]>>>;
+      height: z.ZodOptional<z.ZodNumber>;
+      hidden: z.ZodOptional<z.ZodBoolean>;
+      rowNumber: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>>;
+    columns: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    mergeCells: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    freezePanes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    autoFilter: z.ZodOptional<z.ZodString>;
+    images: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    charts: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    dataValidations: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    conditionalFormats: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  }, z.core.$loose>>;
+  title: z.ZodOptional<z.ZodString>;
+  subject: z.ZodOptional<z.ZodString>;
+  creator: z.ZodOptional<z.ZodString>;
+  keywords: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+  lastModifiedBy: z.ZodOptional<z.ZodString>;
+  revision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+//#endregion
+//#region src/schemas/index.d.ts
+declare const SCHEMAS: {
+  readonly docx: import("zod").ZodObject<{
+    sections: import("zod").ZodArray<import("zod").ZodObject<{
+      properties: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+      children: import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>, import("zod").ZodString]>>;
+      headers: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+      footers: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    }, import("zod/v4/core").$loose>>;
+    title: import("zod").ZodOptional<import("zod").ZodString>;
+    subject: import("zod").ZodOptional<import("zod").ZodString>;
+    creator: import("zod").ZodOptional<import("zod").ZodString>;
+    keywords: import("zod").ZodOptional<import("zod").ZodString>;
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+    lastModifiedBy: import("zod").ZodOptional<import("zod").ZodString>;
+    revision: import("zod").ZodOptional<import("zod").ZodNumber>;
+    externalStyles: import("zod").ZodOptional<import("zod").ZodString>;
+    styles: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    numbering: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    comments: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    bibliography: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    footnotes: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    endnotes: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    background: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    features: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    compatabilityModeVersion: import("zod").ZodOptional<import("zod").ZodNumber>;
+    compatibility: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    customProperties: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    evenAndOddHeaderAndFooters: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    defaultTabStop: import("zod").ZodOptional<import("zod").ZodNumber>;
+    fonts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    hyphenation: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    characterSpacingControl: import("zod").ZodOptional<import("zod").ZodString>;
+    view: import("zod").ZodOptional<import("zod").ZodString>;
+    zoom: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    writeProtection: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    displayBackgroundShape: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    embedTrueTypeFonts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    embedSystemFonts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    saveSubsetFonts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    docVars: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    colorSchemeMapping: import("zod").ZodOptional<import("zod").ZodUnknown>;
+  }, import("zod/v4/core").$loose>;
+  readonly pptx: import("zod").ZodObject<{
+    slides: import("zod").ZodArray<import("zod").ZodObject<{
+      children: import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>, import("zod").ZodString]>>;
+      background: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+      transition: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+      notes: import("zod").ZodOptional<import("zod").ZodString>;
+      layout: import("zod").ZodOptional<import("zod").ZodString>;
+      master: import("zod").ZodOptional<import("zod").ZodString>;
+      comments: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+      headerFooter: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    }, import("zod/v4/core").$loose>>;
+    size: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
+      "16:9": "16:9";
+      "4:3": "4:3";
+    }>, import("zod").ZodObject<{
+      width: import("zod").ZodNumber;
+      height: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>]>>;
+    masters: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    show: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    title: import("zod").ZodOptional<import("zod").ZodString>;
+    subject: import("zod").ZodOptional<import("zod").ZodString>;
+    creator: import("zod").ZodOptional<import("zod").ZodString>;
+    keywords: import("zod").ZodOptional<import("zod").ZodString>;
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+    lastModifiedBy: import("zod").ZodOptional<import("zod").ZodString>;
+    revision: import("zod").ZodOptional<import("zod").ZodNumber>;
+  }, import("zod/v4/core").$loose>;
+  readonly xlsx: import("zod").ZodObject<{
+    worksheets: import("zod").ZodArray<import("zod").ZodObject<{
+      name: import("zod").ZodOptional<import("zod").ZodString>;
+      children: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        cells: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean]>]>>>;
+        height: import("zod").ZodOptional<import("zod").ZodNumber>;
+        hidden: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        rowNumber: import("zod").ZodOptional<import("zod").ZodNumber>;
+      }, import("zod/v4/core").$loose>>>;
+      columns: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+      mergeCells: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+      freezePanes: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+      autoFilter: import("zod").ZodOptional<import("zod").ZodString>;
+      images: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+      charts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+      dataValidations: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+      conditionalFormats: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    }, import("zod/v4/core").$loose>>;
+    title: import("zod").ZodOptional<import("zod").ZodString>;
+    subject: import("zod").ZodOptional<import("zod").ZodString>;
+    creator: import("zod").ZodOptional<import("zod").ZodString>;
+    keywords: import("zod").ZodOptional<import("zod").ZodString>;
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+    lastModifiedBy: import("zod").ZodOptional<import("zod").ZodString>;
+    revision: import("zod").ZodOptional<import("zod").ZodNumber>;
+  }, import("zod/v4/core").$loose>;
+};
+type DocumentType = "docx" | "pptx" | "xlsx";
+declare function validateDocumentInput(type: DocumentType, data: unknown): Record<string, unknown>;
+//#endregion
+export { DocumentType, SCHEMAS, docxSchema, pptxSchema, validateDocumentInput, xlsxSchema };
+//# sourceMappingURL=index.d.mts.map

package/dist/schemas/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/schemas/docx.ts","../../src/schemas/pptx.ts","../../src/schemas/xlsx.ts","../../src/schemas/index.ts"],"mappings":";;;cAIa,UAAA,EAAU,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCAV,UAAA,EAAU,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCAV,UAAA,EAAU,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCIV,OAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMD,YAAA;AAAA,iBAEI,qBAAA,CAAsB,IAAA,EAAM,YAAA,EAAc,IAAA,YAAgB,MAAM"}

package/dist/schemas/index.mjs

@@ -0,0 +1,2 @@
+import { a as docxSchema, i as pptxSchema, n as validateDocumentInput, r as xlsxSchema, t as SCHEMAS } from "../schemas-BbRmv4RW.mjs";
+export { SCHEMAS, docxSchema, pptxSchema, validateDocumentInput, xlsxSchema };

package/dist/schemas-BbRmv4RW.mjs

@@ -0,0 +1,125 @@
+import { z } from "zod";
+//#region src/schemas/docx.ts
+const anyObject$2 = z.record(z.string(), z.unknown()).describe("JSON object");
+const docxSchema = z.object({
+	sections: z.array(z.object({
+		properties: anyObject$2.optional(),
+		children: z.array(anyObject$2.or(z.string())).describe("Section content: paragraphs ({ paragraph: {...} }), tables ({ table: {...} }), images, TOCs, etc."),
+		headers: anyObject$2.optional(),
+		footers: anyObject$2.optional()
+	}).passthrough()).describe("Document sections (required)"),
+	title: z.string().optional(),
+	subject: z.string().optional(),
+	creator: z.string().optional(),
+	keywords: z.string().optional(),
+	description: z.string().optional(),
+	lastModifiedBy: z.string().optional(),
+	revision: z.number().optional(),
+	externalStyles: z.string().optional(),
+	styles: anyObject$2.optional(),
+	numbering: anyObject$2.optional(),
+	comments: anyObject$2.optional(),
+	bibliography: anyObject$2.optional(),
+	footnotes: z.record(z.string(), anyObject$2).optional(),
+	endnotes: z.record(z.string(), anyObject$2).optional(),
+	background: anyObject$2.optional(),
+	features: anyObject$2.optional(),
+	compatabilityModeVersion: z.number().optional(),
+	compatibility: anyObject$2.optional(),
+	customProperties: z.array(anyObject$2).optional(),
+	evenAndOddHeaderAndFooters: z.boolean().optional(),
+	defaultTabStop: z.number().optional(),
+	fonts: z.array(anyObject$2).optional(),
+	hyphenation: anyObject$2.optional(),
+	characterSpacingControl: z.string().optional(),
+	view: z.string().optional(),
+	zoom: anyObject$2.optional(),
+	writeProtection: anyObject$2.optional(),
+	displayBackgroundShape: z.boolean().optional(),
+	embedTrueTypeFonts: z.boolean().optional(),
+	embedSystemFonts: z.boolean().optional(),
+	saveSubsetFonts: z.boolean().optional(),
+	docVars: z.array(anyObject$2).optional(),
+	colorSchemeMapping: z.unknown().optional()
+}).passthrough();
+//#endregion
+//#region src/schemas/pptx.ts
+const anyObject$1 = z.record(z.string(), z.unknown()).describe("JSON object");
+const pptxSchema = z.object({
+	slides: z.array(z.object({
+		children: z.array(anyObject$1.or(z.string())).describe("Slide content: shapes ({ shape: {...} }), pictures ({ picture: {...} }), tables, charts, groups, lines, etc."),
+		background: anyObject$1.optional(),
+		transition: anyObject$1.optional(),
+		notes: z.string().optional(),
+		layout: z.string().optional(),
+		master: z.string().optional(),
+		comments: z.array(anyObject$1).optional(),
+		headerFooter: anyObject$1.optional()
+	}).passthrough()).describe("Presentation slides (required)"),
+	size: z.union([z.enum(["16:9", "4:3"]), z.object({
+		width: z.number(),
+		height: z.number()
+	})]).optional().describe("Slide size: \"16:9\", \"4:3\", or { width, height }"),
+	masters: z.array(anyObject$1).optional().describe("Slide master definitions"),
+	show: anyObject$1.optional(),
+	title: z.string().optional(),
+	subject: z.string().optional(),
+	creator: z.string().optional(),
+	keywords: z.string().optional(),
+	description: z.string().optional(),
+	lastModifiedBy: z.string().optional(),
+	revision: z.number().optional()
+}).passthrough();
+//#endregion
+//#region src/schemas/xlsx.ts
+const anyObject = z.record(z.string(), z.unknown()).describe("JSON object");
+const xlsxSchema = z.object({
+	worksheets: z.array(z.object({
+		name: z.string().optional().describe("Sheet display name"),
+		children: z.array(z.object({
+			cells: z.array(anyObject.or(z.union([
+				z.string(),
+				z.number(),
+				z.boolean()
+			]))).optional(),
+			height: z.number().optional(),
+			hidden: z.boolean().optional(),
+			rowNumber: z.number().optional()
+		}).passthrough()).optional().describe("Worksheet rows, each with \"cells\" array. NOTE: use \"children\" not \"rows\""),
+		columns: z.array(anyObject).optional(),
+		mergeCells: z.array(anyObject).optional(),
+		freezePanes: anyObject.optional(),
+		autoFilter: z.string().optional(),
+		images: z.array(anyObject).optional(),
+		charts: z.array(anyObject).optional(),
+		dataValidations: z.array(anyObject).optional(),
+		conditionalFormats: z.array(anyObject).optional()
+	}).passthrough()).describe("Workbook worksheets (required)"),
+	title: z.string().optional(),
+	subject: z.string().optional(),
+	creator: z.string().optional(),
+	keywords: z.string().optional(),
+	description: z.string().optional(),
+	lastModifiedBy: z.string().optional(),
+	revision: z.number().optional()
+}).passthrough();
+//#endregion
+//#region src/schemas/index.ts
+const SCHEMAS = {
+	docx: docxSchema,
+	pptx: pptxSchema,
+	xlsx: xlsxSchema
+};
+function validateDocumentInput(type, data) {
+	const result = SCHEMAS[type].safeParse(data);
+	if (!result.success) {
+		const issue = result.error.issues[0];
+		const path = issue.path.join(".");
+		throw new Error(`Invalid ${type} options${path ? ` at "${path}"` : ""}: ${issue.message}`);
+	}
+	return result.data;
+}
+//#endregion
+export { docxSchema as a, pptxSchema as i, validateDocumentInput as n, xlsxSchema as r, SCHEMAS as t };
+
+//# sourceMappingURL=schemas-BbRmv4RW.mjs.map

package/dist/schemas-BbRmv4RW.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas-BbRmv4RW.mjs","names":["anyObject","anyObject"],"sources":["../src/schemas/docx.ts","../src/schemas/pptx.ts","../src/schemas/xlsx.ts","../src/schemas/index.ts"],"sourcesContent":["import { z } from \"zod\";\n\nconst anyObject = z.record(z.string(), z.unknown()).describe(\"JSON object\");\n\nexport const docxSchema = z\n  .object({\n    sections: z\n      .array(\n        z\n          .object({\n            properties: anyObject.optional(),\n            children: z\n              .array(anyObject.or(z.string()))\n              .describe(\n                \"Section content: paragraphs ({ paragraph: {...} }), tables ({ table: {...} }), images, TOCs, etc.\",\n              ),\n            headers: anyObject.optional(),\n            footers: anyObject.optional(),\n          })\n          .passthrough(),\n      )\n      .describe(\"Document sections (required)\"),\n    title: z.string().optional(),\n    subject: z.string().optional(),\n    creator: z.string().optional(),\n    keywords: z.string().optional(),\n    description: z.string().optional(),\n    lastModifiedBy: z.string().optional(),\n    revision: z.number().optional(),\n    externalStyles: z.string().optional(),\n    styles: anyObject.optional(),\n    numbering: anyObject.optional(),\n    comments: anyObject.optional(),\n    bibliography: anyObject.optional(),\n    footnotes: z.record(z.string(), anyObject).optional(),\n    endnotes: z.record(z.string(), anyObject).optional(),\n    background: anyObject.optional(),\n    features: anyObject.optional(),\n    compatabilityModeVersion: z.number().optional(),\n    compatibility: anyObject.optional(),\n    customProperties: z.array(anyObject).optional(),\n    evenAndOddHeaderAndFooters: z.boolean().optional(),\n    defaultTabStop: z.number().optional(),\n    fonts: z.array(anyObject).optional(),\n    hyphenation: anyObject.optional(),\n    characterSpacingControl: z.string().optional(),\n    view: z.string().optional(),\n    zoom: anyObject.optional(),\n    writeProtection: anyObject.optional(),\n    displayBackgroundShape: z.boolean().optional(),\n    embedTrueTypeFonts: z.boolean().optional(),\n    embedSystemFonts: z.boolean().optional(),\n    saveSubsetFonts: z.boolean().optional(),\n    docVars: z.array(anyObject).optional(),\n    colorSchemeMapping: z.unknown().optional(),\n  })\n  .passthrough();\n","import { z } from \"zod\";\n\nconst anyObject = z.record(z.string(), z.unknown()).describe(\"JSON object\");\n\nexport const pptxSchema = z\n  .object({\n    slides: z\n      .array(\n        z\n          .object({\n            children: z\n              .array(anyObject.or(z.string()))\n              .describe(\n                \"Slide content: shapes ({ shape: {...} }), pictures ({ picture: {...} }), tables, charts, groups, lines, etc.\",\n              ),\n            background: anyObject.optional(),\n            transition: anyObject.optional(),\n            notes: z.string().optional(),\n            layout: z.string().optional(),\n            master: z.string().optional(),\n            comments: z.array(anyObject).optional(),\n            headerFooter: anyObject.optional(),\n          })\n          .passthrough(),\n      )\n      .describe(\"Presentation slides (required)\"),\n    size: z\n      .union([z.enum([\"16:9\", \"4:3\"]), z.object({ width: z.number(), height: z.number() })])\n      .optional()\n      .describe('Slide size: \"16:9\", \"4:3\", or { width, height }'),\n    masters: z.array(anyObject).optional().describe(\"Slide master definitions\"),\n    show: anyObject.optional(),\n    title: z.string().optional(),\n    subject: z.string().optional(),\n    creator: z.string().optional(),\n    keywords: z.string().optional(),\n    description: z.string().optional(),\n    lastModifiedBy: z.string().optional(),\n    revision: z.number().optional(),\n  })\n  .passthrough();\n","import { z } from \"zod\";\n\nconst anyObject = z.record(z.string(), z.unknown()).describe(\"JSON object\");\n\nexport const xlsxSchema = z\n  .object({\n    worksheets: z\n      .array(\n        z\n          .object({\n            name: z.string().optional().describe(\"Sheet display name\"),\n            children: z\n              .array(\n                z\n                  .object({\n                    cells: z\n                      .array(anyObject.or(z.union([z.string(), z.number(), z.boolean()])))\n                      .optional(),\n                    height: z.number().optional(),\n                    hidden: z.boolean().optional(),\n                    rowNumber: z.number().optional(),\n                  })\n                  .passthrough(),\n              )\n              .optional()\n              .describe('Worksheet rows, each with \"cells\" array. NOTE: use \"children\" not \"rows\"'),\n            columns: z.array(anyObject).optional(),\n            mergeCells: z.array(anyObject).optional(),\n            freezePanes: anyObject.optional(),\n            autoFilter: z.string().optional(),\n            images: z.array(anyObject).optional(),\n            charts: z.array(anyObject).optional(),\n            dataValidations: z.array(anyObject).optional(),\n            conditionalFormats: z.array(anyObject).optional(),\n          })\n          .passthrough(),\n      )\n      .describe(\"Workbook worksheets (required)\"),\n    title: z.string().optional(),\n    subject: z.string().optional(),\n    creator: z.string().optional(),\n    keywords: z.string().optional(),\n    description: z.string().optional(),\n    lastModifiedBy: z.string().optional(),\n    revision: z.number().optional(),\n  })\n  .passthrough();\n","import { docxSchema } from \"./docx\";\nimport { pptxSchema } from \"./pptx\";\nimport { xlsxSchema } from \"./xlsx\";\n\nexport { docxSchema } from \"./docx\";\nexport { pptxSchema } from \"./pptx\";\nexport { xlsxSchema } from \"./xlsx\";\n\nexport const SCHEMAS = {\n  docx: docxSchema,\n  pptx: pptxSchema,\n  xlsx: xlsxSchema,\n} as const;\n\nexport type DocumentType = \"docx\" | \"pptx\" | \"xlsx\";\n\nexport function validateDocumentInput(type: DocumentType, data: unknown): Record<string, unknown> {\n  const result = SCHEMAS[type].safeParse(data);\n  if (!result.success) {\n    const issue = result.error.issues[0];\n    const path = issue.path.join(\".\");\n    throw new Error(`Invalid ${type} options${path ? ` at \"${path}\"` : \"\"}: ${issue.message}`);\n  }\n  return result.data as Record<string, unknown>;\n}\n"],"mappings":"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"}

package/dist/xlsx.d.mts

@@ -0,0 +1 @@
+export * from "@office-open/xlsx";

package/dist/xlsx.mjs

@@ -0,0 +1,2 @@
+export * from "@office-open/xlsx";
+export {};

package/dist/xml.d.mts

@@ -0,0 +1 @@
+export * from "@office-open/xml";

package/dist/xml.mjs

@@ -0,0 +1,2 @@
+export * from "@office-open/xml";
+export {};

package/package.json

@@ -1,12 +1,103 @@
 {
   "name": "office-open",
-  "version": "0.0.0",
-  "description": "",
-  "main": "index.js",
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
+  "version": "0.6.9",
+  "description": "Generate Office files (.docx, .pptx, .xlsx) from JSON — CLI, AI SDK tools, and unified re-exports",
+  "keywords": [
+    "ai",
+    "cli",
+    "docx",
+    "llm",
+    "office",
+    "office-open",
+    "ooxml",
+    "pptx",
+    "xlsx"
+  ],
+  "homepage": "https://www.office-open.com",
+  "bugs": {
+    "url": "https://github.com/DemoMacro/office-open/issues"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Demo Macro",
+    "email": "abc@imst.xyz",
+    "url": "https://imst.xyz/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DemoMacro/office-open.git"
+  },
+  "bin": {
+    "office-open": "dist/cli.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./docx": {
+      "types": "./dist/docx.d.mts",
+      "import": "./dist/docx.mjs"
+    },
+    "./pptx": {
+      "types": "./dist/pptx.d.mts",
+      "import": "./dist/pptx.mjs"
+    },
+    "./xlsx": {
+      "types": "./dist/xlsx.d.mts",
+      "import": "./dist/xlsx.mjs"
+    },
+    "./core": {
+      "types": "./dist/core.d.mts",
+      "import": "./dist/core.mjs"
+    },
+    "./xml": {
+      "types": "./dist/xml.d.mts",
+      "import": "./dist/xml.mjs"
+    },
+    "./ai": {
+      "types": "./dist/ai/index.d.mts",
+      "import": "./dist/ai/index.mjs"
+    },
+    "./generate": {
+      "types": "./dist/generate.d.mts",
+      "import": "./dist/generate.mjs"
+    },
+    "./schemas": {
+      "types": "./dist/schemas/index.d.mts",
+      "import": "./dist/schemas/index.mjs"
+    }
+  },
+  "dependencies": {
+    "citty": "0.2.2",
+    "zod": "4.4.3",
+    "@office-open/core": "0.6.9",
+    "@office-open/docx": "0.6.9",
+    "@office-open/xml": "0.6.9",
+    "@office-open/xlsx": "0.6.9",
+    "@office-open/pptx": "0.6.9"
+  },
+  "peerDependencies": {
+    "ai": "^6.0.0"
+  },
+  "peerDependenciesMeta": {
+    "ai": {
+      "optional": true
+    }
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "dev": "basis build --stub",
+    "build": "vp pack",
+    "test": "vp test run",
+    "check": "vp check --fix",
+    "demo:docx": "node dist/cli.mjs docx demo/1-basic-docx.json \"My Document.docx\"",
+    "demo:pptx": "node dist/cli.mjs pptx demo/1-basic-pptx.json \"My Presentation.pptx\"",
+    "demo:xlsx": "node dist/cli.mjs xlsx demo/1-basic-xlsx.json \"My Workbook.xlsx\""
   }
 }