@pdfme/common 4.5.2 → 5.0.0-dev.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +82 -11
- package/dist/cjs/__tests__/helper.test.js +213 -62
- package/dist/cjs/__tests__/helper.test.js.map +1 -1
- package/dist/cjs/src/constants.js +1 -1
- package/dist/cjs/src/helper.js +84 -53
- package/dist/cjs/src/helper.js.map +1 -1
- package/dist/cjs/src/index.js.map +1 -1
- package/dist/cjs/src/schema.js +7 -6
- package/dist/cjs/src/schema.js.map +1 -1
- package/dist/esm/__tests__/helper.test.js +214 -63
- package/dist/esm/__tests__/helper.test.js.map +1 -1
- package/dist/esm/src/constants.js +1 -1
- package/dist/esm/src/helper.js +80 -50
- package/dist/esm/src/helper.js.map +1 -1
- package/dist/esm/src/index.js.map +1 -1
- package/dist/esm/src/schema.js +6 -5
- package/dist/esm/src/schema.js.map +1 -1
- package/dist/types/src/constants.d.ts +1 -1
- package/dist/types/src/helper.d.ts +7 -2
- package/dist/types/src/index.d.ts +2 -2
- package/dist/types/src/schema.d.ts +293 -49
- package/dist/types/src/types.d.ts +3 -4
- package/package.json +1 -1
- package/src/constants.ts +1 -1
- package/src/helper.ts +96 -50
- package/src/index.ts +2 -0
- package/src/schema.ts +7 -5
- package/src/types.ts +4 -3
| @@ -206,6 +206,7 @@ export declare const Size: z.ZodObject<{ | |
| 206 206 | 
             
                height: number;
         | 
| 207 207 | 
             
            }>;
         | 
| 208 208 | 
             
            export declare const Schema: z.ZodObject<{
         | 
| 209 | 
            +
                name: z.ZodString;
         | 
| 209 210 | 
             
                type: z.ZodString;
         | 
| 210 211 | 
             
                content: z.ZodOptional<z.ZodString>;
         | 
| 211 212 | 
             
                position: z.ZodObject<{
         | 
| @@ -236,6 +237,7 @@ export declare const Schema: z.ZodObject<{ | |
| 236 237 | 
             
                }>>;
         | 
| 237 238 | 
             
                __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 238 239 | 
             
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 240 | 
            +
                name: z.ZodString;
         | 
| 239 241 | 
             
                type: z.ZodString;
         | 
| 240 242 | 
             
                content: z.ZodOptional<z.ZodString>;
         | 
| 241 243 | 
             
                position: z.ZodObject<{
         | 
| @@ -266,6 +268,7 @@ export declare const Schema: z.ZodObject<{ | |
| 266 268 | 
             
                }>>;
         | 
| 267 269 | 
             
                __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 268 270 | 
             
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 271 | 
            +
                name: z.ZodString;
         | 
| 269 272 | 
             
                type: z.ZodString;
         | 
| 270 273 | 
             
                content: z.ZodOptional<z.ZodString>;
         | 
| 271 274 | 
             
                position: z.ZodObject<{
         | 
| @@ -303,6 +306,7 @@ export declare const SchemaForUI: z.ZodObject<{ | |
| 303 306 | 
             
                rotate: z.ZodOptional<z.ZodNumber>;
         | 
| 304 307 | 
             
                required: z.ZodOptional<z.ZodBoolean>;
         | 
| 305 308 | 
             
                type: z.ZodString;
         | 
| 309 | 
            +
                name: z.ZodString;
         | 
| 306 310 | 
             
                content: z.ZodOptional<z.ZodString>;
         | 
| 307 311 | 
             
                position: z.ZodObject<{
         | 
| 308 312 | 
             
                    x: z.ZodNumber;
         | 
| @@ -327,17 +331,16 @@ export declare const SchemaForUI: z.ZodObject<{ | |
| 327 331 | 
             
                }>>;
         | 
| 328 332 | 
             
                __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 329 333 | 
             
                id: z.ZodString;
         | 
| 330 | 
            -
                key: z.ZodString;
         | 
| 331 334 | 
             
            }, "strip", z.ZodTypeAny, {
         | 
| 332 335 | 
             
                width: number;
         | 
| 333 336 | 
             
                height: number;
         | 
| 334 337 | 
             
                type: string;
         | 
| 338 | 
            +
                name: string;
         | 
| 335 339 | 
             
                position: {
         | 
| 336 340 | 
             
                    x: number;
         | 
| 337 341 | 
             
                    y: number;
         | 
| 338 342 | 
             
                };
         | 
| 339 343 | 
             
                id: string;
         | 
| 340 | 
            -
                key: string;
         | 
| 341 344 | 
             
                opacity?: number | undefined;
         | 
| 342 345 | 
             
                rotate?: number | undefined;
         | 
| 343 346 | 
             
                required?: boolean | undefined;
         | 
| @@ -352,12 +355,12 @@ export declare const SchemaForUI: z.ZodObject<{ | |
| 352 355 | 
             
                width: number;
         | 
| 353 356 | 
             
                height: number;
         | 
| 354 357 | 
             
                type: string;
         | 
| 358 | 
            +
                name: string;
         | 
| 355 359 | 
             
                position: {
         | 
| 356 360 | 
             
                    x: number;
         | 
| 357 361 | 
             
                    y: number;
         | 
| 358 362 | 
             
                };
         | 
| 359 363 | 
             
                id: string;
         | 
| 360 | 
            -
                key: string;
         | 
| 361 364 | 
             
                opacity?: number | undefined;
         | 
| 362 365 | 
             
                rotate?: number | undefined;
         | 
| 363 366 | 
             
                required?: boolean | undefined;
         | 
| @@ -395,8 +398,197 @@ export declare const BasePdf: z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<Arr | |
| 395 398 | 
             
                height: number;
         | 
| 396 399 | 
             
                padding: [number, number, number, number];
         | 
| 397 400 | 
             
            }>]>;
         | 
| 401 | 
            +
            export declare const LegacySchemaPageArray: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodObject<{
         | 
| 402 | 
            +
                name: z.ZodString;
         | 
| 403 | 
            +
                type: z.ZodString;
         | 
| 404 | 
            +
                content: z.ZodOptional<z.ZodString>;
         | 
| 405 | 
            +
                position: z.ZodObject<{
         | 
| 406 | 
            +
                    x: z.ZodNumber;
         | 
| 407 | 
            +
                    y: z.ZodNumber;
         | 
| 408 | 
            +
                }, "strip", z.ZodTypeAny, {
         | 
| 409 | 
            +
                    x: number;
         | 
| 410 | 
            +
                    y: number;
         | 
| 411 | 
            +
                }, {
         | 
| 412 | 
            +
                    x: number;
         | 
| 413 | 
            +
                    y: number;
         | 
| 414 | 
            +
                }>;
         | 
| 415 | 
            +
                width: z.ZodNumber;
         | 
| 416 | 
            +
                height: z.ZodNumber;
         | 
| 417 | 
            +
                rotate: z.ZodOptional<z.ZodNumber>;
         | 
| 418 | 
            +
                opacity: z.ZodOptional<z.ZodNumber>;
         | 
| 419 | 
            +
                readOnly: z.ZodOptional<z.ZodBoolean>;
         | 
| 420 | 
            +
                required: z.ZodOptional<z.ZodBoolean>;
         | 
| 421 | 
            +
                __bodyRange: z.ZodOptional<z.ZodObject<{
         | 
| 422 | 
            +
                    start: z.ZodNumber;
         | 
| 423 | 
            +
                    end: z.ZodOptional<z.ZodNumber>;
         | 
| 424 | 
            +
                }, "strip", z.ZodTypeAny, {
         | 
| 425 | 
            +
                    start: number;
         | 
| 426 | 
            +
                    end?: number | undefined;
         | 
| 427 | 
            +
                }, {
         | 
| 428 | 
            +
                    start: number;
         | 
| 429 | 
            +
                    end?: number | undefined;
         | 
| 430 | 
            +
                }>>;
         | 
| 431 | 
            +
                __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 432 | 
            +
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 433 | 
            +
                name: z.ZodString;
         | 
| 434 | 
            +
                type: z.ZodString;
         | 
| 435 | 
            +
                content: z.ZodOptional<z.ZodString>;
         | 
| 436 | 
            +
                position: z.ZodObject<{
         | 
| 437 | 
            +
                    x: z.ZodNumber;
         | 
| 438 | 
            +
                    y: z.ZodNumber;
         | 
| 439 | 
            +
                }, "strip", z.ZodTypeAny, {
         | 
| 440 | 
            +
                    x: number;
         | 
| 441 | 
            +
                    y: number;
         | 
| 442 | 
            +
                }, {
         | 
| 443 | 
            +
                    x: number;
         | 
| 444 | 
            +
                    y: number;
         | 
| 445 | 
            +
                }>;
         | 
| 446 | 
            +
                width: z.ZodNumber;
         | 
| 447 | 
            +
                height: z.ZodNumber;
         | 
| 448 | 
            +
                rotate: z.ZodOptional<z.ZodNumber>;
         | 
| 449 | 
            +
                opacity: z.ZodOptional<z.ZodNumber>;
         | 
| 450 | 
            +
                readOnly: z.ZodOptional<z.ZodBoolean>;
         | 
| 451 | 
            +
                required: z.ZodOptional<z.ZodBoolean>;
         | 
| 452 | 
            +
                __bodyRange: z.ZodOptional<z.ZodObject<{
         | 
| 453 | 
            +
                    start: z.ZodNumber;
         | 
| 454 | 
            +
                    end: z.ZodOptional<z.ZodNumber>;
         | 
| 455 | 
            +
                }, "strip", z.ZodTypeAny, {
         | 
| 456 | 
            +
                    start: number;
         | 
| 457 | 
            +
                    end?: number | undefined;
         | 
| 458 | 
            +
                }, {
         | 
| 459 | 
            +
                    start: number;
         | 
| 460 | 
            +
                    end?: number | undefined;
         | 
| 461 | 
            +
                }>>;
         | 
| 462 | 
            +
                __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 463 | 
            +
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 464 | 
            +
                name: z.ZodString;
         | 
| 465 | 
            +
                type: z.ZodString;
         | 
| 466 | 
            +
                content: z.ZodOptional<z.ZodString>;
         | 
| 467 | 
            +
                position: z.ZodObject<{
         | 
| 468 | 
            +
                    x: z.ZodNumber;
         | 
| 469 | 
            +
                    y: z.ZodNumber;
         | 
| 470 | 
            +
                }, "strip", z.ZodTypeAny, {
         | 
| 471 | 
            +
                    x: number;
         | 
| 472 | 
            +
                    y: number;
         | 
| 473 | 
            +
                }, {
         | 
| 474 | 
            +
                    x: number;
         | 
| 475 | 
            +
                    y: number;
         | 
| 476 | 
            +
                }>;
         | 
| 477 | 
            +
                width: z.ZodNumber;
         | 
| 478 | 
            +
                height: z.ZodNumber;
         | 
| 479 | 
            +
                rotate: z.ZodOptional<z.ZodNumber>;
         | 
| 480 | 
            +
                opacity: z.ZodOptional<z.ZodNumber>;
         | 
| 481 | 
            +
                readOnly: z.ZodOptional<z.ZodBoolean>;
         | 
| 482 | 
            +
                required: z.ZodOptional<z.ZodBoolean>;
         | 
| 483 | 
            +
                __bodyRange: z.ZodOptional<z.ZodObject<{
         | 
| 484 | 
            +
                    start: z.ZodNumber;
         | 
| 485 | 
            +
                    end: z.ZodOptional<z.ZodNumber>;
         | 
| 486 | 
            +
                }, "strip", z.ZodTypeAny, {
         | 
| 487 | 
            +
                    start: number;
         | 
| 488 | 
            +
                    end?: number | undefined;
         | 
| 489 | 
            +
                }, {
         | 
| 490 | 
            +
                    start: number;
         | 
| 491 | 
            +
                    end?: number | undefined;
         | 
| 492 | 
            +
                }>>;
         | 
| 493 | 
            +
                __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 494 | 
            +
            }, z.ZodTypeAny, "passthrough">>>, "many">;
         | 
| 495 | 
            +
            export declare const SchemaPageArray: z.ZodArray<z.ZodArray<z.ZodObject<{
         | 
| 496 | 
            +
                name: z.ZodString;
         | 
| 497 | 
            +
                type: z.ZodString;
         | 
| 498 | 
            +
                content: z.ZodOptional<z.ZodString>;
         | 
| 499 | 
            +
                position: z.ZodObject<{
         | 
| 500 | 
            +
                    x: z.ZodNumber;
         | 
| 501 | 
            +
                    y: z.ZodNumber;
         | 
| 502 | 
            +
                }, "strip", z.ZodTypeAny, {
         | 
| 503 | 
            +
                    x: number;
         | 
| 504 | 
            +
                    y: number;
         | 
| 505 | 
            +
                }, {
         | 
| 506 | 
            +
                    x: number;
         | 
| 507 | 
            +
                    y: number;
         | 
| 508 | 
            +
                }>;
         | 
| 509 | 
            +
                width: z.ZodNumber;
         | 
| 510 | 
            +
                height: z.ZodNumber;
         | 
| 511 | 
            +
                rotate: z.ZodOptional<z.ZodNumber>;
         | 
| 512 | 
            +
                opacity: z.ZodOptional<z.ZodNumber>;
         | 
| 513 | 
            +
                readOnly: z.ZodOptional<z.ZodBoolean>;
         | 
| 514 | 
            +
                required: z.ZodOptional<z.ZodBoolean>;
         | 
| 515 | 
            +
                __bodyRange: z.ZodOptional<z.ZodObject<{
         | 
| 516 | 
            +
                    start: z.ZodNumber;
         | 
| 517 | 
            +
                    end: z.ZodOptional<z.ZodNumber>;
         | 
| 518 | 
            +
                }, "strip", z.ZodTypeAny, {
         | 
| 519 | 
            +
                    start: number;
         | 
| 520 | 
            +
                    end?: number | undefined;
         | 
| 521 | 
            +
                }, {
         | 
| 522 | 
            +
                    start: number;
         | 
| 523 | 
            +
                    end?: number | undefined;
         | 
| 524 | 
            +
                }>>;
         | 
| 525 | 
            +
                __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 526 | 
            +
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 527 | 
            +
                name: z.ZodString;
         | 
| 528 | 
            +
                type: z.ZodString;
         | 
| 529 | 
            +
                content: z.ZodOptional<z.ZodString>;
         | 
| 530 | 
            +
                position: z.ZodObject<{
         | 
| 531 | 
            +
                    x: z.ZodNumber;
         | 
| 532 | 
            +
                    y: z.ZodNumber;
         | 
| 533 | 
            +
                }, "strip", z.ZodTypeAny, {
         | 
| 534 | 
            +
                    x: number;
         | 
| 535 | 
            +
                    y: number;
         | 
| 536 | 
            +
                }, {
         | 
| 537 | 
            +
                    x: number;
         | 
| 538 | 
            +
                    y: number;
         | 
| 539 | 
            +
                }>;
         | 
| 540 | 
            +
                width: z.ZodNumber;
         | 
| 541 | 
            +
                height: z.ZodNumber;
         | 
| 542 | 
            +
                rotate: z.ZodOptional<z.ZodNumber>;
         | 
| 543 | 
            +
                opacity: z.ZodOptional<z.ZodNumber>;
         | 
| 544 | 
            +
                readOnly: z.ZodOptional<z.ZodBoolean>;
         | 
| 545 | 
            +
                required: z.ZodOptional<z.ZodBoolean>;
         | 
| 546 | 
            +
                __bodyRange: z.ZodOptional<z.ZodObject<{
         | 
| 547 | 
            +
                    start: z.ZodNumber;
         | 
| 548 | 
            +
                    end: z.ZodOptional<z.ZodNumber>;
         | 
| 549 | 
            +
                }, "strip", z.ZodTypeAny, {
         | 
| 550 | 
            +
                    start: number;
         | 
| 551 | 
            +
                    end?: number | undefined;
         | 
| 552 | 
            +
                }, {
         | 
| 553 | 
            +
                    start: number;
         | 
| 554 | 
            +
                    end?: number | undefined;
         | 
| 555 | 
            +
                }>>;
         | 
| 556 | 
            +
                __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 557 | 
            +
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 558 | 
            +
                name: z.ZodString;
         | 
| 559 | 
            +
                type: z.ZodString;
         | 
| 560 | 
            +
                content: z.ZodOptional<z.ZodString>;
         | 
| 561 | 
            +
                position: z.ZodObject<{
         | 
| 562 | 
            +
                    x: z.ZodNumber;
         | 
| 563 | 
            +
                    y: z.ZodNumber;
         | 
| 564 | 
            +
                }, "strip", z.ZodTypeAny, {
         | 
| 565 | 
            +
                    x: number;
         | 
| 566 | 
            +
                    y: number;
         | 
| 567 | 
            +
                }, {
         | 
| 568 | 
            +
                    x: number;
         | 
| 569 | 
            +
                    y: number;
         | 
| 570 | 
            +
                }>;
         | 
| 571 | 
            +
                width: z.ZodNumber;
         | 
| 572 | 
            +
                height: z.ZodNumber;
         | 
| 573 | 
            +
                rotate: z.ZodOptional<z.ZodNumber>;
         | 
| 574 | 
            +
                opacity: z.ZodOptional<z.ZodNumber>;
         | 
| 575 | 
            +
                readOnly: z.ZodOptional<z.ZodBoolean>;
         | 
| 576 | 
            +
                required: z.ZodOptional<z.ZodBoolean>;
         | 
| 577 | 
            +
                __bodyRange: z.ZodOptional<z.ZodObject<{
         | 
| 578 | 
            +
                    start: z.ZodNumber;
         | 
| 579 | 
            +
                    end: z.ZodOptional<z.ZodNumber>;
         | 
| 580 | 
            +
                }, "strip", z.ZodTypeAny, {
         | 
| 581 | 
            +
                    start: number;
         | 
| 582 | 
            +
                    end?: number | undefined;
         | 
| 583 | 
            +
                }, {
         | 
| 584 | 
            +
                    start: number;
         | 
| 585 | 
            +
                    end?: number | undefined;
         | 
| 586 | 
            +
                }>>;
         | 
| 587 | 
            +
                __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 588 | 
            +
            }, z.ZodTypeAny, "passthrough">>, "many">, "many">;
         | 
| 398 589 | 
             
            export declare const Template: z.ZodObject<{
         | 
| 399 | 
            -
                schemas: z.ZodArray<z. | 
| 590 | 
            +
                schemas: z.ZodArray<z.ZodArray<z.ZodObject<{
         | 
| 591 | 
            +
                    name: z.ZodString;
         | 
| 400 592 | 
             
                    type: z.ZodString;
         | 
| 401 593 | 
             
                    content: z.ZodOptional<z.ZodString>;
         | 
| 402 594 | 
             
                    position: z.ZodObject<{
         | 
| @@ -427,6 +619,7 @@ export declare const Template: z.ZodObject<{ | |
| 427 619 | 
             
                    }>>;
         | 
| 428 620 | 
             
                    __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 429 621 | 
             
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 622 | 
            +
                    name: z.ZodString;
         | 
| 430 623 | 
             
                    type: z.ZodString;
         | 
| 431 624 | 
             
                    content: z.ZodOptional<z.ZodString>;
         | 
| 432 625 | 
             
                    position: z.ZodObject<{
         | 
| @@ -457,6 +650,7 @@ export declare const Template: z.ZodObject<{ | |
| 457 650 | 
             
                    }>>;
         | 
| 458 651 | 
             
                    __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 459 652 | 
             
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 653 | 
            +
                    name: z.ZodString;
         | 
| 460 654 | 
             
                    type: z.ZodString;
         | 
| 461 655 | 
             
                    content: z.ZodOptional<z.ZodString>;
         | 
| 462 656 | 
             
                    position: z.ZodObject<{
         | 
| @@ -486,7 +680,7 @@ export declare const Template: z.ZodObject<{ | |
| 486 680 | 
             
                        end?: number | undefined;
         | 
| 487 681 | 
             
                    }>>;
         | 
| 488 682 | 
             
                    __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 489 | 
            -
                }, z.ZodTypeAny, "passthrough" | 
| 683 | 
            +
                }, z.ZodTypeAny, "passthrough">>, "many">, "many">;
         | 
| 490 684 | 
             
                basePdf: z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<ArrayBuffer, z.ZodTypeDef, ArrayBuffer>, z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>]>, z.ZodObject<{
         | 
| 491 685 | 
             
                    width: z.ZodNumber;
         | 
| 492 686 | 
             
                    height: z.ZodNumber;
         | 
| @@ -502,7 +696,8 @@ export declare const Template: z.ZodObject<{ | |
| 502 696 | 
             
                }>]>;
         | 
| 503 697 | 
             
                pdfmeVersion: z.ZodOptional<z.ZodString>;
         | 
| 504 698 | 
             
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 505 | 
            -
                schemas: z.ZodArray<z. | 
| 699 | 
            +
                schemas: z.ZodArray<z.ZodArray<z.ZodObject<{
         | 
| 700 | 
            +
                    name: z.ZodString;
         | 
| 506 701 | 
             
                    type: z.ZodString;
         | 
| 507 702 | 
             
                    content: z.ZodOptional<z.ZodString>;
         | 
| 508 703 | 
             
                    position: z.ZodObject<{
         | 
| @@ -533,6 +728,7 @@ export declare const Template: z.ZodObject<{ | |
| 533 728 | 
             
                    }>>;
         | 
| 534 729 | 
             
                    __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 535 730 | 
             
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 731 | 
            +
                    name: z.ZodString;
         | 
| 536 732 | 
             
                    type: z.ZodString;
         | 
| 537 733 | 
             
                    content: z.ZodOptional<z.ZodString>;
         | 
| 538 734 | 
             
                    position: z.ZodObject<{
         | 
| @@ -563,6 +759,7 @@ export declare const Template: z.ZodObject<{ | |
| 563 759 | 
             
                    }>>;
         | 
| 564 760 | 
             
                    __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 565 761 | 
             
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 762 | 
            +
                    name: z.ZodString;
         | 
| 566 763 | 
             
                    type: z.ZodString;
         | 
| 567 764 | 
             
                    content: z.ZodOptional<z.ZodString>;
         | 
| 568 765 | 
             
                    position: z.ZodObject<{
         | 
| @@ -592,7 +789,7 @@ export declare const Template: z.ZodObject<{ | |
| 592 789 | 
             
                        end?: number | undefined;
         | 
| 593 790 | 
             
                    }>>;
         | 
| 594 791 | 
             
                    __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 595 | 
            -
                }, z.ZodTypeAny, "passthrough" | 
| 792 | 
            +
                }, z.ZodTypeAny, "passthrough">>, "many">, "many">;
         | 
| 596 793 | 
             
                basePdf: z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<ArrayBuffer, z.ZodTypeDef, ArrayBuffer>, z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>]>, z.ZodObject<{
         | 
| 597 794 | 
             
                    width: z.ZodNumber;
         | 
| 598 795 | 
             
                    height: z.ZodNumber;
         | 
| @@ -608,7 +805,8 @@ export declare const Template: z.ZodObject<{ | |
| 608 805 | 
             
                }>]>;
         | 
| 609 806 | 
             
                pdfmeVersion: z.ZodOptional<z.ZodString>;
         | 
| 610 807 | 
             
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 611 | 
            -
                schemas: z.ZodArray<z. | 
| 808 | 
            +
                schemas: z.ZodArray<z.ZodArray<z.ZodObject<{
         | 
| 809 | 
            +
                    name: z.ZodString;
         | 
| 612 810 | 
             
                    type: z.ZodString;
         | 
| 613 811 | 
             
                    content: z.ZodOptional<z.ZodString>;
         | 
| 614 812 | 
             
                    position: z.ZodObject<{
         | 
| @@ -639,6 +837,7 @@ export declare const Template: z.ZodObject<{ | |
| 639 837 | 
             
                    }>>;
         | 
| 640 838 | 
             
                    __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 641 839 | 
             
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 840 | 
            +
                    name: z.ZodString;
         | 
| 642 841 | 
             
                    type: z.ZodString;
         | 
| 643 842 | 
             
                    content: z.ZodOptional<z.ZodString>;
         | 
| 644 843 | 
             
                    position: z.ZodObject<{
         | 
| @@ -669,6 +868,7 @@ export declare const Template: z.ZodObject<{ | |
| 669 868 | 
             
                    }>>;
         | 
| 670 869 | 
             
                    __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 671 870 | 
             
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 871 | 
            +
                    name: z.ZodString;
         | 
| 672 872 | 
             
                    type: z.ZodString;
         | 
| 673 873 | 
             
                    content: z.ZodOptional<z.ZodString>;
         | 
| 674 874 | 
             
                    position: z.ZodObject<{
         | 
| @@ -698,7 +898,7 @@ export declare const Template: z.ZodObject<{ | |
| 698 898 | 
             
                        end?: number | undefined;
         | 
| 699 899 | 
             
                    }>>;
         | 
| 700 900 | 
             
                    __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 701 | 
            -
                }, z.ZodTypeAny, "passthrough" | 
| 901 | 
            +
                }, z.ZodTypeAny, "passthrough">>, "many">, "many">;
         | 
| 702 902 | 
             
                basePdf: z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<ArrayBuffer, z.ZodTypeDef, ArrayBuffer>, z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>]>, z.ZodObject<{
         | 
| 703 903 | 
             
                    width: z.ZodNumber;
         | 
| 704 904 | 
             
                    height: z.ZodNumber;
         | 
| @@ -846,7 +1046,8 @@ export declare const GeneratorOptions: z.ZodObject<{ | |
| 846 1046 | 
             
            }, z.ZodTypeAny, "passthrough">>;
         | 
| 847 1047 | 
             
            export declare const GenerateProps: z.ZodObject<{
         | 
| 848 1048 | 
             
                template: z.ZodObject<{
         | 
| 849 | 
            -
                    schemas: z.ZodArray<z. | 
| 1049 | 
            +
                    schemas: z.ZodArray<z.ZodArray<z.ZodObject<{
         | 
| 1050 | 
            +
                        name: z.ZodString;
         | 
| 850 1051 | 
             
                        type: z.ZodString;
         | 
| 851 1052 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 852 1053 | 
             
                        position: z.ZodObject<{
         | 
| @@ -877,6 +1078,7 @@ export declare const GenerateProps: z.ZodObject<{ | |
| 877 1078 | 
             
                        }>>;
         | 
| 878 1079 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 879 1080 | 
             
                    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 1081 | 
            +
                        name: z.ZodString;
         | 
| 880 1082 | 
             
                        type: z.ZodString;
         | 
| 881 1083 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 882 1084 | 
             
                        position: z.ZodObject<{
         | 
| @@ -907,6 +1109,7 @@ export declare const GenerateProps: z.ZodObject<{ | |
| 907 1109 | 
             
                        }>>;
         | 
| 908 1110 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 909 1111 | 
             
                    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 1112 | 
            +
                        name: z.ZodString;
         | 
| 910 1113 | 
             
                        type: z.ZodString;
         | 
| 911 1114 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 912 1115 | 
             
                        position: z.ZodObject<{
         | 
| @@ -936,7 +1139,7 @@ export declare const GenerateProps: z.ZodObject<{ | |
| 936 1139 | 
             
                            end?: number | undefined;
         | 
| 937 1140 | 
             
                        }>>;
         | 
| 938 1141 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 939 | 
            -
                    }, z.ZodTypeAny, "passthrough" | 
| 1142 | 
            +
                    }, z.ZodTypeAny, "passthrough">>, "many">, "many">;
         | 
| 940 1143 | 
             
                    basePdf: z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<ArrayBuffer, z.ZodTypeDef, ArrayBuffer>, z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>]>, z.ZodObject<{
         | 
| 941 1144 | 
             
                        width: z.ZodNumber;
         | 
| 942 1145 | 
             
                        height: z.ZodNumber;
         | 
| @@ -952,7 +1155,8 @@ export declare const GenerateProps: z.ZodObject<{ | |
| 952 1155 | 
             
                    }>]>;
         | 
| 953 1156 | 
             
                    pdfmeVersion: z.ZodOptional<z.ZodString>;
         | 
| 954 1157 | 
             
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 955 | 
            -
                    schemas: z.ZodArray<z. | 
| 1158 | 
            +
                    schemas: z.ZodArray<z.ZodArray<z.ZodObject<{
         | 
| 1159 | 
            +
                        name: z.ZodString;
         | 
| 956 1160 | 
             
                        type: z.ZodString;
         | 
| 957 1161 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 958 1162 | 
             
                        position: z.ZodObject<{
         | 
| @@ -983,6 +1187,7 @@ export declare const GenerateProps: z.ZodObject<{ | |
| 983 1187 | 
             
                        }>>;
         | 
| 984 1188 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 985 1189 | 
             
                    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 1190 | 
            +
                        name: z.ZodString;
         | 
| 986 1191 | 
             
                        type: z.ZodString;
         | 
| 987 1192 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 988 1193 | 
             
                        position: z.ZodObject<{
         | 
| @@ -1013,6 +1218,7 @@ export declare const GenerateProps: z.ZodObject<{ | |
| 1013 1218 | 
             
                        }>>;
         | 
| 1014 1219 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 1015 1220 | 
             
                    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 1221 | 
            +
                        name: z.ZodString;
         | 
| 1016 1222 | 
             
                        type: z.ZodString;
         | 
| 1017 1223 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 1018 1224 | 
             
                        position: z.ZodObject<{
         | 
| @@ -1042,7 +1248,7 @@ export declare const GenerateProps: z.ZodObject<{ | |
| 1042 1248 | 
             
                            end?: number | undefined;
         | 
| 1043 1249 | 
             
                        }>>;
         | 
| 1044 1250 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 1045 | 
            -
                    }, z.ZodTypeAny, "passthrough" | 
| 1251 | 
            +
                    }, z.ZodTypeAny, "passthrough">>, "many">, "many">;
         | 
| 1046 1252 | 
             
                    basePdf: z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<ArrayBuffer, z.ZodTypeDef, ArrayBuffer>, z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>]>, z.ZodObject<{
         | 
| 1047 1253 | 
             
                        width: z.ZodNumber;
         | 
| 1048 1254 | 
             
                        height: z.ZodNumber;
         | 
| @@ -1058,7 +1264,8 @@ export declare const GenerateProps: z.ZodObject<{ | |
| 1058 1264 | 
             
                    }>]>;
         | 
| 1059 1265 | 
             
                    pdfmeVersion: z.ZodOptional<z.ZodString>;
         | 
| 1060 1266 | 
             
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 1061 | 
            -
                    schemas: z.ZodArray<z. | 
| 1267 | 
            +
                    schemas: z.ZodArray<z.ZodArray<z.ZodObject<{
         | 
| 1268 | 
            +
                        name: z.ZodString;
         | 
| 1062 1269 | 
             
                        type: z.ZodString;
         | 
| 1063 1270 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 1064 1271 | 
             
                        position: z.ZodObject<{
         | 
| @@ -1089,6 +1296,7 @@ export declare const GenerateProps: z.ZodObject<{ | |
| 1089 1296 | 
             
                        }>>;
         | 
| 1090 1297 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 1091 1298 | 
             
                    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 1299 | 
            +
                        name: z.ZodString;
         | 
| 1092 1300 | 
             
                        type: z.ZodString;
         | 
| 1093 1301 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 1094 1302 | 
             
                        position: z.ZodObject<{
         | 
| @@ -1119,6 +1327,7 @@ export declare const GenerateProps: z.ZodObject<{ | |
| 1119 1327 | 
             
                        }>>;
         | 
| 1120 1328 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 1121 1329 | 
             
                    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 1330 | 
            +
                        name: z.ZodString;
         | 
| 1122 1331 | 
             
                        type: z.ZodString;
         | 
| 1123 1332 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 1124 1333 | 
             
                        position: z.ZodObject<{
         | 
| @@ -1148,7 +1357,7 @@ export declare const GenerateProps: z.ZodObject<{ | |
| 1148 1357 | 
             
                            end?: number | undefined;
         | 
| 1149 1358 | 
             
                        }>>;
         | 
| 1150 1359 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 1151 | 
            -
                    }, z.ZodTypeAny, "passthrough" | 
| 1360 | 
            +
                    }, z.ZodTypeAny, "passthrough">>, "many">, "many">;
         | 
| 1152 1361 | 
             
                    basePdf: z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<ArrayBuffer, z.ZodTypeDef, ArrayBuffer>, z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>]>, z.ZodObject<{
         | 
| 1153 1362 | 
             
                        width: z.ZodNumber;
         | 
| 1154 1363 | 
             
                        height: z.ZodNumber;
         | 
| @@ -1253,7 +1462,8 @@ export declare const GenerateProps: z.ZodObject<{ | |
| 1253 1462 | 
             
                }, z.ZodTypeAny, "passthrough">>>;
         | 
| 1254 1463 | 
             
            }, "strict", z.ZodTypeAny, {
         | 
| 1255 1464 | 
             
                template: {
         | 
| 1256 | 
            -
                    schemas:  | 
| 1465 | 
            +
                    schemas: z.objectOutputType<{
         | 
| 1466 | 
            +
                        name: z.ZodString;
         | 
| 1257 1467 | 
             
                        type: z.ZodString;
         | 
| 1258 1468 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 1259 1469 | 
             
                        position: z.ZodObject<{
         | 
| @@ -1283,7 +1493,7 @@ export declare const GenerateProps: z.ZodObject<{ | |
| 1283 1493 | 
             
                            end?: number | undefined;
         | 
| 1284 1494 | 
             
                        }>>;
         | 
| 1285 1495 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 1286 | 
            -
                    }, z.ZodTypeAny, "passthrough" | 
| 1496 | 
            +
                    }, z.ZodTypeAny, "passthrough">[][];
         | 
| 1287 1497 | 
             
                    basePdf: (string | ArrayBuffer | Uint8Array | {
         | 
| 1288 1498 | 
             
                        width: number;
         | 
| 1289 1499 | 
             
                        height: number;
         | 
| @@ -1330,7 +1540,8 @@ export declare const GenerateProps: z.ZodObject<{ | |
| 1330 1540 | 
             
                }, z.ZodTypeAny, "passthrough"> | undefined;
         | 
| 1331 1541 | 
             
            }, {
         | 
| 1332 1542 | 
             
                template: {
         | 
| 1333 | 
            -
                    schemas:  | 
| 1543 | 
            +
                    schemas: z.objectInputType<{
         | 
| 1544 | 
            +
                        name: z.ZodString;
         | 
| 1334 1545 | 
             
                        type: z.ZodString;
         | 
| 1335 1546 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 1336 1547 | 
             
                        position: z.ZodObject<{
         | 
| @@ -1360,7 +1571,7 @@ export declare const GenerateProps: z.ZodObject<{ | |
| 1360 1571 | 
             
                            end?: number | undefined;
         | 
| 1361 1572 | 
             
                        }>>;
         | 
| 1362 1573 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 1363 | 
            -
                    }, z.ZodTypeAny, "passthrough" | 
| 1574 | 
            +
                    }, z.ZodTypeAny, "passthrough">[][];
         | 
| 1364 1575 | 
             
                    basePdf: (string | ArrayBuffer | Uint8Array | {
         | 
| 1365 1576 | 
             
                        width: number;
         | 
| 1366 1577 | 
             
                        height: number;
         | 
| @@ -1466,7 +1677,8 @@ export declare const UIOptions: z.ZodObject<{ | |
| 1466 1677 | 
             
            }, z.ZodTypeAny, "passthrough">>;
         | 
| 1467 1678 | 
             
            export declare const UIProps: z.ZodObject<{
         | 
| 1468 1679 | 
             
                template: z.ZodObject<{
         | 
| 1469 | 
            -
                    schemas: z.ZodArray<z. | 
| 1680 | 
            +
                    schemas: z.ZodArray<z.ZodArray<z.ZodObject<{
         | 
| 1681 | 
            +
                        name: z.ZodString;
         | 
| 1470 1682 | 
             
                        type: z.ZodString;
         | 
| 1471 1683 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 1472 1684 | 
             
                        position: z.ZodObject<{
         | 
| @@ -1497,6 +1709,7 @@ export declare const UIProps: z.ZodObject<{ | |
| 1497 1709 | 
             
                        }>>;
         | 
| 1498 1710 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 1499 1711 | 
             
                    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 1712 | 
            +
                        name: z.ZodString;
         | 
| 1500 1713 | 
             
                        type: z.ZodString;
         | 
| 1501 1714 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 1502 1715 | 
             
                        position: z.ZodObject<{
         | 
| @@ -1527,6 +1740,7 @@ export declare const UIProps: z.ZodObject<{ | |
| 1527 1740 | 
             
                        }>>;
         | 
| 1528 1741 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 1529 1742 | 
             
                    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 1743 | 
            +
                        name: z.ZodString;
         | 
| 1530 1744 | 
             
                        type: z.ZodString;
         | 
| 1531 1745 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 1532 1746 | 
             
                        position: z.ZodObject<{
         | 
| @@ -1556,7 +1770,7 @@ export declare const UIProps: z.ZodObject<{ | |
| 1556 1770 | 
             
                            end?: number | undefined;
         | 
| 1557 1771 | 
             
                        }>>;
         | 
| 1558 1772 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 1559 | 
            -
                    }, z.ZodTypeAny, "passthrough" | 
| 1773 | 
            +
                    }, z.ZodTypeAny, "passthrough">>, "many">, "many">;
         | 
| 1560 1774 | 
             
                    basePdf: z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<ArrayBuffer, z.ZodTypeDef, ArrayBuffer>, z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>]>, z.ZodObject<{
         | 
| 1561 1775 | 
             
                        width: z.ZodNumber;
         | 
| 1562 1776 | 
             
                        height: z.ZodNumber;
         | 
| @@ -1572,7 +1786,8 @@ export declare const UIProps: z.ZodObject<{ | |
| 1572 1786 | 
             
                    }>]>;
         | 
| 1573 1787 | 
             
                    pdfmeVersion: z.ZodOptional<z.ZodString>;
         | 
| 1574 1788 | 
             
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 1575 | 
            -
                    schemas: z.ZodArray<z. | 
| 1789 | 
            +
                    schemas: z.ZodArray<z.ZodArray<z.ZodObject<{
         | 
| 1790 | 
            +
                        name: z.ZodString;
         | 
| 1576 1791 | 
             
                        type: z.ZodString;
         | 
| 1577 1792 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 1578 1793 | 
             
                        position: z.ZodObject<{
         | 
| @@ -1603,6 +1818,7 @@ export declare const UIProps: z.ZodObject<{ | |
| 1603 1818 | 
             
                        }>>;
         | 
| 1604 1819 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 1605 1820 | 
             
                    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 1821 | 
            +
                        name: z.ZodString;
         | 
| 1606 1822 | 
             
                        type: z.ZodString;
         | 
| 1607 1823 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 1608 1824 | 
             
                        position: z.ZodObject<{
         | 
| @@ -1633,6 +1849,7 @@ export declare const UIProps: z.ZodObject<{ | |
| 1633 1849 | 
             
                        }>>;
         | 
| 1634 1850 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 1635 1851 | 
             
                    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 1852 | 
            +
                        name: z.ZodString;
         | 
| 1636 1853 | 
             
                        type: z.ZodString;
         | 
| 1637 1854 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 1638 1855 | 
             
                        position: z.ZodObject<{
         | 
| @@ -1662,7 +1879,7 @@ export declare const UIProps: z.ZodObject<{ | |
| 1662 1879 | 
             
                            end?: number | undefined;
         | 
| 1663 1880 | 
             
                        }>>;
         | 
| 1664 1881 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 1665 | 
            -
                    }, z.ZodTypeAny, "passthrough" | 
| 1882 | 
            +
                    }, z.ZodTypeAny, "passthrough">>, "many">, "many">;
         | 
| 1666 1883 | 
             
                    basePdf: z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<ArrayBuffer, z.ZodTypeDef, ArrayBuffer>, z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>]>, z.ZodObject<{
         | 
| 1667 1884 | 
             
                        width: z.ZodNumber;
         | 
| 1668 1885 | 
             
                        height: z.ZodNumber;
         | 
| @@ -1678,7 +1895,8 @@ export declare const UIProps: z.ZodObject<{ | |
| 1678 1895 | 
             
                    }>]>;
         | 
| 1679 1896 | 
             
                    pdfmeVersion: z.ZodOptional<z.ZodString>;
         | 
| 1680 1897 | 
             
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 1681 | 
            -
                    schemas: z.ZodArray<z. | 
| 1898 | 
            +
                    schemas: z.ZodArray<z.ZodArray<z.ZodObject<{
         | 
| 1899 | 
            +
                        name: z.ZodString;
         | 
| 1682 1900 | 
             
                        type: z.ZodString;
         | 
| 1683 1901 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 1684 1902 | 
             
                        position: z.ZodObject<{
         | 
| @@ -1709,6 +1927,7 @@ export declare const UIProps: z.ZodObject<{ | |
| 1709 1927 | 
             
                        }>>;
         | 
| 1710 1928 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 1711 1929 | 
             
                    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 1930 | 
            +
                        name: z.ZodString;
         | 
| 1712 1931 | 
             
                        type: z.ZodString;
         | 
| 1713 1932 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 1714 1933 | 
             
                        position: z.ZodObject<{
         | 
| @@ -1739,6 +1958,7 @@ export declare const UIProps: z.ZodObject<{ | |
| 1739 1958 | 
             
                        }>>;
         | 
| 1740 1959 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 1741 1960 | 
             
                    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 1961 | 
            +
                        name: z.ZodString;
         | 
| 1742 1962 | 
             
                        type: z.ZodString;
         | 
| 1743 1963 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 1744 1964 | 
             
                        position: z.ZodObject<{
         | 
| @@ -1768,7 +1988,7 @@ export declare const UIProps: z.ZodObject<{ | |
| 1768 1988 | 
             
                            end?: number | undefined;
         | 
| 1769 1989 | 
             
                        }>>;
         | 
| 1770 1990 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 1771 | 
            -
                    }, z.ZodTypeAny, "passthrough" | 
| 1991 | 
            +
                    }, z.ZodTypeAny, "passthrough">>, "many">, "many">;
         | 
| 1772 1992 | 
             
                    basePdf: z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<ArrayBuffer, z.ZodTypeDef, ArrayBuffer>, z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>]>, z.ZodObject<{
         | 
| 1773 1993 | 
             
                        width: z.ZodNumber;
         | 
| 1774 1994 | 
             
                        height: z.ZodNumber;
         | 
| @@ -1858,7 +2078,8 @@ export declare const UIProps: z.ZodObject<{ | |
| 1858 2078 | 
             
                }, z.ZodTypeAny, "passthrough">>>;
         | 
| 1859 2079 | 
             
            }, "strip", z.ZodTypeAny, {
         | 
| 1860 2080 | 
             
                template: {
         | 
| 1861 | 
            -
                    schemas:  | 
| 2081 | 
            +
                    schemas: z.objectOutputType<{
         | 
| 2082 | 
            +
                        name: z.ZodString;
         | 
| 1862 2083 | 
             
                        type: z.ZodString;
         | 
| 1863 2084 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 1864 2085 | 
             
                        position: z.ZodObject<{
         | 
| @@ -1888,7 +2109,7 @@ export declare const UIProps: z.ZodObject<{ | |
| 1888 2109 | 
             
                            end?: number | undefined;
         | 
| 1889 2110 | 
             
                        }>>;
         | 
| 1890 2111 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 1891 | 
            -
                    }, z.ZodTypeAny, "passthrough" | 
| 2112 | 
            +
                    }, z.ZodTypeAny, "passthrough">[][];
         | 
| 1892 2113 | 
             
                    basePdf: (string | ArrayBuffer | Uint8Array | {
         | 
| 1893 2114 | 
             
                        width: number;
         | 
| 1894 2115 | 
             
                        height: number;
         | 
| @@ -1930,7 +2151,8 @@ export declare const UIProps: z.ZodObject<{ | |
| 1930 2151 | 
             
                }, z.ZodTypeAny, "passthrough"> | undefined;
         | 
| 1931 2152 | 
             
            }, {
         | 
| 1932 2153 | 
             
                template: {
         | 
| 1933 | 
            -
                    schemas:  | 
| 2154 | 
            +
                    schemas: z.objectInputType<{
         | 
| 2155 | 
            +
                        name: z.ZodString;
         | 
| 1934 2156 | 
             
                        type: z.ZodString;
         | 
| 1935 2157 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 1936 2158 | 
             
                        position: z.ZodObject<{
         | 
| @@ -1960,7 +2182,7 @@ export declare const UIProps: z.ZodObject<{ | |
| 1960 2182 | 
             
                            end?: number | undefined;
         | 
| 1961 2183 | 
             
                        }>>;
         | 
| 1962 2184 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 1963 | 
            -
                    }, z.ZodTypeAny, "passthrough" | 
| 2185 | 
            +
                    }, z.ZodTypeAny, "passthrough">[][];
         | 
| 1964 2186 | 
             
                    basePdf: (string | ArrayBuffer | Uint8Array | {
         | 
| 1965 2187 | 
             
                        width: number;
         | 
| 1966 2188 | 
             
                        height: number;
         | 
| @@ -2061,7 +2283,8 @@ export declare const PreviewProps: z.ZodObject<{ | |
| 2061 2283 | 
             
                    requiredByDefault: z.ZodOptional<z.ZodBoolean>;
         | 
| 2062 2284 | 
             
                }, z.ZodTypeAny, "passthrough">>>;
         | 
| 2063 2285 | 
             
                template: z.ZodObject<{
         | 
| 2064 | 
            -
                    schemas: z.ZodArray<z. | 
| 2286 | 
            +
                    schemas: z.ZodArray<z.ZodArray<z.ZodObject<{
         | 
| 2287 | 
            +
                        name: z.ZodString;
         | 
| 2065 2288 | 
             
                        type: z.ZodString;
         | 
| 2066 2289 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2067 2290 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2092,6 +2315,7 @@ export declare const PreviewProps: z.ZodObject<{ | |
| 2092 2315 | 
             
                        }>>;
         | 
| 2093 2316 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2094 2317 | 
             
                    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 2318 | 
            +
                        name: z.ZodString;
         | 
| 2095 2319 | 
             
                        type: z.ZodString;
         | 
| 2096 2320 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2097 2321 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2122,6 +2346,7 @@ export declare const PreviewProps: z.ZodObject<{ | |
| 2122 2346 | 
             
                        }>>;
         | 
| 2123 2347 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2124 2348 | 
             
                    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 2349 | 
            +
                        name: z.ZodString;
         | 
| 2125 2350 | 
             
                        type: z.ZodString;
         | 
| 2126 2351 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2127 2352 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2151,7 +2376,7 @@ export declare const PreviewProps: z.ZodObject<{ | |
| 2151 2376 | 
             
                            end?: number | undefined;
         | 
| 2152 2377 | 
             
                        }>>;
         | 
| 2153 2378 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2154 | 
            -
                    }, z.ZodTypeAny, "passthrough" | 
| 2379 | 
            +
                    }, z.ZodTypeAny, "passthrough">>, "many">, "many">;
         | 
| 2155 2380 | 
             
                    basePdf: z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<ArrayBuffer, z.ZodTypeDef, ArrayBuffer>, z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>]>, z.ZodObject<{
         | 
| 2156 2381 | 
             
                        width: z.ZodNumber;
         | 
| 2157 2382 | 
             
                        height: z.ZodNumber;
         | 
| @@ -2167,7 +2392,8 @@ export declare const PreviewProps: z.ZodObject<{ | |
| 2167 2392 | 
             
                    }>]>;
         | 
| 2168 2393 | 
             
                    pdfmeVersion: z.ZodOptional<z.ZodString>;
         | 
| 2169 2394 | 
             
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 2170 | 
            -
                    schemas: z.ZodArray<z. | 
| 2395 | 
            +
                    schemas: z.ZodArray<z.ZodArray<z.ZodObject<{
         | 
| 2396 | 
            +
                        name: z.ZodString;
         | 
| 2171 2397 | 
             
                        type: z.ZodString;
         | 
| 2172 2398 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2173 2399 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2198,6 +2424,7 @@ export declare const PreviewProps: z.ZodObject<{ | |
| 2198 2424 | 
             
                        }>>;
         | 
| 2199 2425 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2200 2426 | 
             
                    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 2427 | 
            +
                        name: z.ZodString;
         | 
| 2201 2428 | 
             
                        type: z.ZodString;
         | 
| 2202 2429 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2203 2430 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2228,6 +2455,7 @@ export declare const PreviewProps: z.ZodObject<{ | |
| 2228 2455 | 
             
                        }>>;
         | 
| 2229 2456 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2230 2457 | 
             
                    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 2458 | 
            +
                        name: z.ZodString;
         | 
| 2231 2459 | 
             
                        type: z.ZodString;
         | 
| 2232 2460 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2233 2461 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2257,7 +2485,7 @@ export declare const PreviewProps: z.ZodObject<{ | |
| 2257 2485 | 
             
                            end?: number | undefined;
         | 
| 2258 2486 | 
             
                        }>>;
         | 
| 2259 2487 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2260 | 
            -
                    }, z.ZodTypeAny, "passthrough" | 
| 2488 | 
            +
                    }, z.ZodTypeAny, "passthrough">>, "many">, "many">;
         | 
| 2261 2489 | 
             
                    basePdf: z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<ArrayBuffer, z.ZodTypeDef, ArrayBuffer>, z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>]>, z.ZodObject<{
         | 
| 2262 2490 | 
             
                        width: z.ZodNumber;
         | 
| 2263 2491 | 
             
                        height: z.ZodNumber;
         | 
| @@ -2273,7 +2501,8 @@ export declare const PreviewProps: z.ZodObject<{ | |
| 2273 2501 | 
             
                    }>]>;
         | 
| 2274 2502 | 
             
                    pdfmeVersion: z.ZodOptional<z.ZodString>;
         | 
| 2275 2503 | 
             
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 2276 | 
            -
                    schemas: z.ZodArray<z. | 
| 2504 | 
            +
                    schemas: z.ZodArray<z.ZodArray<z.ZodObject<{
         | 
| 2505 | 
            +
                        name: z.ZodString;
         | 
| 2277 2506 | 
             
                        type: z.ZodString;
         | 
| 2278 2507 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2279 2508 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2304,6 +2533,7 @@ export declare const PreviewProps: z.ZodObject<{ | |
| 2304 2533 | 
             
                        }>>;
         | 
| 2305 2534 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2306 2535 | 
             
                    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 2536 | 
            +
                        name: z.ZodString;
         | 
| 2307 2537 | 
             
                        type: z.ZodString;
         | 
| 2308 2538 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2309 2539 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2334,6 +2564,7 @@ export declare const PreviewProps: z.ZodObject<{ | |
| 2334 2564 | 
             
                        }>>;
         | 
| 2335 2565 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2336 2566 | 
             
                    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 2567 | 
            +
                        name: z.ZodString;
         | 
| 2337 2568 | 
             
                        type: z.ZodString;
         | 
| 2338 2569 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2339 2570 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2363,7 +2594,7 @@ export declare const PreviewProps: z.ZodObject<{ | |
| 2363 2594 | 
             
                            end?: number | undefined;
         | 
| 2364 2595 | 
             
                        }>>;
         | 
| 2365 2596 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2366 | 
            -
                    }, z.ZodTypeAny, "passthrough" | 
| 2597 | 
            +
                    }, z.ZodTypeAny, "passthrough">>, "many">, "many">;
         | 
| 2367 2598 | 
             
                    basePdf: z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<ArrayBuffer, z.ZodTypeDef, ArrayBuffer>, z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>]>, z.ZodObject<{
         | 
| 2368 2599 | 
             
                        width: z.ZodNumber;
         | 
| 2369 2600 | 
             
                        height: z.ZodNumber;
         | 
| @@ -2396,7 +2627,8 @@ export declare const PreviewProps: z.ZodObject<{ | |
| 2396 2627 | 
             
                inputs: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">;
         | 
| 2397 2628 | 
             
            }, "strict", z.ZodTypeAny, {
         | 
| 2398 2629 | 
             
                template: {
         | 
| 2399 | 
            -
                    schemas:  | 
| 2630 | 
            +
                    schemas: z.objectOutputType<{
         | 
| 2631 | 
            +
                        name: z.ZodString;
         | 
| 2400 2632 | 
             
                        type: z.ZodString;
         | 
| 2401 2633 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2402 2634 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2426,7 +2658,7 @@ export declare const PreviewProps: z.ZodObject<{ | |
| 2426 2658 | 
             
                            end?: number | undefined;
         | 
| 2427 2659 | 
             
                        }>>;
         | 
| 2428 2660 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2429 | 
            -
                    }, z.ZodTypeAny, "passthrough" | 
| 2661 | 
            +
                    }, z.ZodTypeAny, "passthrough">[][];
         | 
| 2430 2662 | 
             
                    basePdf: (string | ArrayBuffer | Uint8Array | {
         | 
| 2431 2663 | 
             
                        width: number;
         | 
| 2432 2664 | 
             
                        height: number;
         | 
| @@ -2469,7 +2701,8 @@ export declare const PreviewProps: z.ZodObject<{ | |
| 2469 2701 | 
             
                }> | undefined;
         | 
| 2470 2702 | 
             
            }, {
         | 
| 2471 2703 | 
             
                template: {
         | 
| 2472 | 
            -
                    schemas:  | 
| 2704 | 
            +
                    schemas: z.objectInputType<{
         | 
| 2705 | 
            +
                        name: z.ZodString;
         | 
| 2473 2706 | 
             
                        type: z.ZodString;
         | 
| 2474 2707 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2475 2708 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2499,7 +2732,7 @@ export declare const PreviewProps: z.ZodObject<{ | |
| 2499 2732 | 
             
                            end?: number | undefined;
         | 
| 2500 2733 | 
             
                        }>>;
         | 
| 2501 2734 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2502 | 
            -
                    }, z.ZodTypeAny, "passthrough" | 
| 2735 | 
            +
                    }, z.ZodTypeAny, "passthrough">[][];
         | 
| 2503 2736 | 
             
                    basePdf: (string | ArrayBuffer | Uint8Array | {
         | 
| 2504 2737 | 
             
                        width: number;
         | 
| 2505 2738 | 
             
                        height: number;
         | 
| @@ -2601,7 +2834,8 @@ export declare const DesignerProps: z.ZodObject<{ | |
| 2601 2834 | 
             
                    requiredByDefault: z.ZodOptional<z.ZodBoolean>;
         | 
| 2602 2835 | 
             
                }, z.ZodTypeAny, "passthrough">>>;
         | 
| 2603 2836 | 
             
                template: z.ZodObject<{
         | 
| 2604 | 
            -
                    schemas: z.ZodArray<z. | 
| 2837 | 
            +
                    schemas: z.ZodArray<z.ZodArray<z.ZodObject<{
         | 
| 2838 | 
            +
                        name: z.ZodString;
         | 
| 2605 2839 | 
             
                        type: z.ZodString;
         | 
| 2606 2840 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2607 2841 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2632,6 +2866,7 @@ export declare const DesignerProps: z.ZodObject<{ | |
| 2632 2866 | 
             
                        }>>;
         | 
| 2633 2867 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2634 2868 | 
             
                    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 2869 | 
            +
                        name: z.ZodString;
         | 
| 2635 2870 | 
             
                        type: z.ZodString;
         | 
| 2636 2871 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2637 2872 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2662,6 +2897,7 @@ export declare const DesignerProps: z.ZodObject<{ | |
| 2662 2897 | 
             
                        }>>;
         | 
| 2663 2898 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2664 2899 | 
             
                    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 2900 | 
            +
                        name: z.ZodString;
         | 
| 2665 2901 | 
             
                        type: z.ZodString;
         | 
| 2666 2902 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2667 2903 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2691,7 +2927,7 @@ export declare const DesignerProps: z.ZodObject<{ | |
| 2691 2927 | 
             
                            end?: number | undefined;
         | 
| 2692 2928 | 
             
                        }>>;
         | 
| 2693 2929 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2694 | 
            -
                    }, z.ZodTypeAny, "passthrough" | 
| 2930 | 
            +
                    }, z.ZodTypeAny, "passthrough">>, "many">, "many">;
         | 
| 2695 2931 | 
             
                    basePdf: z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<ArrayBuffer, z.ZodTypeDef, ArrayBuffer>, z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>]>, z.ZodObject<{
         | 
| 2696 2932 | 
             
                        width: z.ZodNumber;
         | 
| 2697 2933 | 
             
                        height: z.ZodNumber;
         | 
| @@ -2707,7 +2943,8 @@ export declare const DesignerProps: z.ZodObject<{ | |
| 2707 2943 | 
             
                    }>]>;
         | 
| 2708 2944 | 
             
                    pdfmeVersion: z.ZodOptional<z.ZodString>;
         | 
| 2709 2945 | 
             
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 2710 | 
            -
                    schemas: z.ZodArray<z. | 
| 2946 | 
            +
                    schemas: z.ZodArray<z.ZodArray<z.ZodObject<{
         | 
| 2947 | 
            +
                        name: z.ZodString;
         | 
| 2711 2948 | 
             
                        type: z.ZodString;
         | 
| 2712 2949 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2713 2950 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2738,6 +2975,7 @@ export declare const DesignerProps: z.ZodObject<{ | |
| 2738 2975 | 
             
                        }>>;
         | 
| 2739 2976 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2740 2977 | 
             
                    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 2978 | 
            +
                        name: z.ZodString;
         | 
| 2741 2979 | 
             
                        type: z.ZodString;
         | 
| 2742 2980 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2743 2981 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2768,6 +3006,7 @@ export declare const DesignerProps: z.ZodObject<{ | |
| 2768 3006 | 
             
                        }>>;
         | 
| 2769 3007 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2770 3008 | 
             
                    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 3009 | 
            +
                        name: z.ZodString;
         | 
| 2771 3010 | 
             
                        type: z.ZodString;
         | 
| 2772 3011 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2773 3012 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2797,7 +3036,7 @@ export declare const DesignerProps: z.ZodObject<{ | |
| 2797 3036 | 
             
                            end?: number | undefined;
         | 
| 2798 3037 | 
             
                        }>>;
         | 
| 2799 3038 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2800 | 
            -
                    }, z.ZodTypeAny, "passthrough" | 
| 3039 | 
            +
                    }, z.ZodTypeAny, "passthrough">>, "many">, "many">;
         | 
| 2801 3040 | 
             
                    basePdf: z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<ArrayBuffer, z.ZodTypeDef, ArrayBuffer>, z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>]>, z.ZodObject<{
         | 
| 2802 3041 | 
             
                        width: z.ZodNumber;
         | 
| 2803 3042 | 
             
                        height: z.ZodNumber;
         | 
| @@ -2813,7 +3052,8 @@ export declare const DesignerProps: z.ZodObject<{ | |
| 2813 3052 | 
             
                    }>]>;
         | 
| 2814 3053 | 
             
                    pdfmeVersion: z.ZodOptional<z.ZodString>;
         | 
| 2815 3054 | 
             
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 2816 | 
            -
                    schemas: z.ZodArray<z. | 
| 3055 | 
            +
                    schemas: z.ZodArray<z.ZodArray<z.ZodObject<{
         | 
| 3056 | 
            +
                        name: z.ZodString;
         | 
| 2817 3057 | 
             
                        type: z.ZodString;
         | 
| 2818 3058 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2819 3059 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2844,6 +3084,7 @@ export declare const DesignerProps: z.ZodObject<{ | |
| 2844 3084 | 
             
                        }>>;
         | 
| 2845 3085 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2846 3086 | 
             
                    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         | 
| 3087 | 
            +
                        name: z.ZodString;
         | 
| 2847 3088 | 
             
                        type: z.ZodString;
         | 
| 2848 3089 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2849 3090 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2874,6 +3115,7 @@ export declare const DesignerProps: z.ZodObject<{ | |
| 2874 3115 | 
             
                        }>>;
         | 
| 2875 3116 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2876 3117 | 
             
                    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         | 
| 3118 | 
            +
                        name: z.ZodString;
         | 
| 2877 3119 | 
             
                        type: z.ZodString;
         | 
| 2878 3120 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2879 3121 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2903,7 +3145,7 @@ export declare const DesignerProps: z.ZodObject<{ | |
| 2903 3145 | 
             
                            end?: number | undefined;
         | 
| 2904 3146 | 
             
                        }>>;
         | 
| 2905 3147 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2906 | 
            -
                    }, z.ZodTypeAny, "passthrough" | 
| 3148 | 
            +
                    }, z.ZodTypeAny, "passthrough">>, "many">, "many">;
         | 
| 2907 3149 | 
             
                    basePdf: z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<ArrayBuffer, z.ZodTypeDef, ArrayBuffer>, z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>]>, z.ZodObject<{
         | 
| 2908 3150 | 
             
                        width: z.ZodNumber;
         | 
| 2909 3151 | 
             
                        height: z.ZodNumber;
         | 
| @@ -2935,7 +3177,8 @@ export declare const DesignerProps: z.ZodObject<{ | |
| 2935 3177 | 
             
                domContainer: z.ZodType<HTMLElement, z.ZodTypeDef, HTMLElement>;
         | 
| 2936 3178 | 
             
            }, "strict", z.ZodTypeAny, {
         | 
| 2937 3179 | 
             
                template: {
         | 
| 2938 | 
            -
                    schemas:  | 
| 3180 | 
            +
                    schemas: z.objectOutputType<{
         | 
| 3181 | 
            +
                        name: z.ZodString;
         | 
| 2939 3182 | 
             
                        type: z.ZodString;
         | 
| 2940 3183 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 2941 3184 | 
             
                        position: z.ZodObject<{
         | 
| @@ -2965,7 +3208,7 @@ export declare const DesignerProps: z.ZodObject<{ | |
| 2965 3208 | 
             
                            end?: number | undefined;
         | 
| 2966 3209 | 
             
                        }>>;
         | 
| 2967 3210 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 2968 | 
            -
                    }, z.ZodTypeAny, "passthrough" | 
| 3211 | 
            +
                    }, z.ZodTypeAny, "passthrough">[][];
         | 
| 2969 3212 | 
             
                    basePdf: (string | ArrayBuffer | Uint8Array | {
         | 
| 2970 3213 | 
             
                        width: number;
         | 
| 2971 3214 | 
             
                        height: number;
         | 
| @@ -3007,7 +3250,8 @@ export declare const DesignerProps: z.ZodObject<{ | |
| 3007 3250 | 
             
                }> | undefined;
         | 
| 3008 3251 | 
             
            }, {
         | 
| 3009 3252 | 
             
                template: {
         | 
| 3010 | 
            -
                    schemas:  | 
| 3253 | 
            +
                    schemas: z.objectInputType<{
         | 
| 3254 | 
            +
                        name: z.ZodString;
         | 
| 3011 3255 | 
             
                        type: z.ZodString;
         | 
| 3012 3256 | 
             
                        content: z.ZodOptional<z.ZodString>;
         | 
| 3013 3257 | 
             
                        position: z.ZodObject<{
         | 
| @@ -3037,7 +3281,7 @@ export declare const DesignerProps: z.ZodObject<{ | |
| 3037 3281 | 
             
                            end?: number | undefined;
         | 
| 3038 3282 | 
             
                        }>>;
         | 
| 3039 3283 | 
             
                        __isSplit: z.ZodOptional<z.ZodBoolean>;
         | 
| 3040 | 
            -
                    }, z.ZodTypeAny, "passthrough" | 
| 3284 | 
            +
                    }, z.ZodTypeAny, "passthrough">[][];
         | 
| 3041 3285 | 
             
                    basePdf: (string | ArrayBuffer | Uint8Array | {
         | 
| 3042 3286 | 
             
                        width: number;
         | 
| 3043 3287 | 
             
                        height: number;
         |