@lokalise/content-conversion-schemas 11.1.0 → 11.2.0

package/dist/api/contentObjects.d.ts

@@ -1,576 +0,0 @@
-/**
- * This file contains schemas for content-related objects.
- *
- * A Content Item is a piece of generic content that can be imported and handled by the system.
- * It consists of content units, which are the smallest parts of the content that a user can manipulate (import, export).
- *
- * When parsed, each content unit is split into text units, which represent the individual pieces of text that can be translated.
- * Each text unit can be further segmented into segments (e.g., individual sentences).
- * Users cannot manipulate text units or segments directly (e.g., remove or add them, otherwise, the system won't be able to
- * reconstruct the content unit properly), but they should be able to influence the text unit extraction process or segmentation rules.
- *
- * In the context of Shopify, a Product would correspond to a Content Item.
- * Two properties of the product, "title" and "description," would be the content units.
- * "title" would be regular text (example: "Premium Cotton T-Shirt"), a single sentence, so it will consist of a single text unit and a single segment.
- * "description" would be HTML content (example: <h1>Product Overview</h1><p>This is a premium cotton t-shirt. It is available in multiple colors.</p>),
- * so it will consist of two text units: one for the <h1> element and another for the <p> element.
- * The <p> element's text unit will contain two segments because it has two sentences.
- *
- * RawContentItem represents the content item before parsing, while ParsedContentItem represents the content item after parsing.
- */
-import { z } from 'zod';
-export declare const RAW_CONTENT_UNIT_SCHEMA: z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodEnum<{
-        readonly HTML_FILE: "HTML_FILE";
-        readonly DOCX_FILE: "DOCX_FILE";
-        readonly PPTX_FILE: "PPTX_FILE";
-        readonly XLSX_FILE: "XLSX_FILE";
-        readonly MARKDOWN_FILE: "MARKDOWN_FILE";
-        readonly IDML_FILE: "IDML_FILE";
-        readonly JSON_FILE: "JSON_FILE";
-        readonly YAML_FILE: "YAML_FILE";
-        readonly XCSTRINGS_FILE: "XCSTRINGS_FILE";
-        readonly TEXT: "TEXT";
-        readonly HTML: "HTML";
-        readonly JSON: "JSON";
-        readonly CONTENTFUL_RICH_TEXT: "CONTENTFUL_RICH_TEXT";
-    }>;
-    source: z.ZodUnion<readonly [z.ZodObject<{
-        type: z.ZodLiteral<"inline">;
-        value: z.ZodString;
-        storageId: z.ZodOptional<z.ZodNever>;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"remote">;
-        storageId: z.ZodString;
-        contentSize: z.ZodOptional<z.ZodString>;
-        filePath: z.ZodOptional<z.ZodString>;
-        value: z.ZodOptional<z.ZodNever>;
-    }, z.core.$strip>]>;
-    context: z.ZodOptional<z.ZodString>;
-    characterLimit: z.ZodOptional<z.ZodNumber>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-}, z.core.$strip>;
-export declare const PARSED_CONTENT_UNIT_METADATA_SCHEMA: z.ZodObject<{
-    pptxAttributes: z.ZodObject<{
-        slideNumber: z.ZodNumber;
-        slideType: z.ZodString;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export declare const PARSED_CONTENT_UNIT_SCHEMA: z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodEnum<{
-        readonly HTML_FILE: "HTML_FILE";
-        readonly DOCX_FILE: "DOCX_FILE";
-        readonly PPTX_FILE: "PPTX_FILE";
-        readonly XLSX_FILE: "XLSX_FILE";
-        readonly MARKDOWN_FILE: "MARKDOWN_FILE";
-        readonly IDML_FILE: "IDML_FILE";
-        readonly JSON_FILE: "JSON_FILE";
-        readonly YAML_FILE: "YAML_FILE";
-        readonly XCSTRINGS_FILE: "XCSTRINGS_FILE";
-        readonly TEXT: "TEXT";
-        readonly HTML: "HTML";
-        readonly JSON: "JSON";
-        readonly CONTENTFUL_RICH_TEXT: "CONTENTFUL_RICH_TEXT";
-    }>;
-    context: z.ZodOptional<z.ZodString>;
-    characterLimit: z.ZodOptional<z.ZodNumber>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    source: z.ZodUnion<readonly [z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
-        type: z.ZodLiteral<"inline">;
-        value: z.ZodString;
-        storageId: z.ZodOptional<z.ZodNever>;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"remote">;
-        storageId: z.ZodString;
-        contentSize: z.ZodOptional<z.ZodString>;
-        filePath: z.ZodOptional<z.ZodString>;
-        value: z.ZodOptional<z.ZodNever>;
-    }, z.core.$strip>]>]>;
-    sourceWordCount: z.ZodNumber;
-    textUnits: z.ZodArray<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-        id: z.ZodString;
-        isTranslatable: z.ZodBoolean;
-        name: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        type: z.ZodOptional<z.ZodString>;
-        skeleton: z.ZodOptional<z.ZodString>;
-        targets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
-            isPlural: z.ZodLiteral<false>;
-            source: z.ZodObject<{
-                hasBeenSegmented: z.ZodBoolean;
-                segments: z.ZodArray<z.ZodString>;
-                metadata: z.ZodOptional<z.ZodObject<{
-                    xcstrings: z.ZodOptional<z.ZodObject<{
-                        state: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    }, z.core.$strip>>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>;
-        }, z.core.$strip>, z.ZodObject<{
-            isPlural: z.ZodLiteral<true>;
-            pluralForms: z.ZodRecord<z.ZodString, z.ZodObject<{
-                hasBeenSegmented: z.ZodBoolean;
-                segments: z.ZodArray<z.ZodString>;
-                metadata: z.ZodOptional<z.ZodObject<{
-                    xcstrings: z.ZodOptional<z.ZodObject<{
-                        state: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    }, z.core.$strip>>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>], "isPlural">>>;
-        metadata: z.ZodOptional<z.ZodObject<{
-            pptxAttributes: z.ZodOptional<z.ZodObject<{
-                slideNumber: z.ZodNumber;
-                slideType: z.ZodEnum<{
-                    readonly LAYOUT: "LAYOUT";
-                    readonly NOTES: "NOTES";
-                    readonly MASTER_NOTES: "MASTER_NOTES";
-                    readonly SLIDE: "SLIDE";
-                    readonly MASTER_SLIDE: "MASTER_SLIDE";
-                    readonly CHART: "CHART";
-                    readonly UNKNOWN: "UNKNOWN";
-                }>;
-            }, z.core.$strip>>;
-            xcstrings: z.ZodOptional<z.ZodObject<{
-                state: z.ZodOptional<z.ZodString>;
-                shouldTranslate: z.ZodOptional<z.ZodBoolean>;
-                extractionState: z.ZodOptional<z.ZodString>;
-                localizationType: z.ZodOptional<z.ZodEnum<{
-                    readonly STRING_UNIT: "STRING_UNIT";
-                    readonly SUBSTITUTIONS: "SUBSTITUTIONS";
-                    readonly PLURAL_VARIATIONS: "PLURAL_VARIATIONS";
-                    readonly DEVICE_VARIATION: "DEVICE_VARIATION";
-                    readonly DEVICE_PLURAL_VARIATION: "DEVICE_PLURAL_VARIATION";
-                }>>;
-                keyPath: z.ZodOptional<z.ZodString>;
-                device: z.ZodOptional<z.ZodEnum<{
-                    readonly MAC: "MAC";
-                    readonly IPHONE: "IPHONE";
-                    readonly APPLE_WATCH: "APPLE_WATCH";
-                    readonly IPAD: "IPAD";
-                    readonly OTHER: "OTHER";
-                }>>;
-                pluralForm: z.ZodOptional<z.ZodEnum<{
-                    readonly ZERO: "ZERO";
-                    readonly ONE: "ONE";
-                    readonly TWO: "TWO";
-                    readonly FEW: "FEW";
-                    readonly MANY: "MANY";
-                    readonly OTHER: "OTHER";
-                }>>;
-                formatSpecifier: z.ZodOptional<z.ZodString>;
-                argNum: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-        isPlural: z.ZodLiteral<true>;
-        pluralForms: z.ZodRecord<z.ZodString, z.ZodObject<{
-            textCodes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                type: z.ZodEnum<{
-                    readonly OPENING: "OPENING";
-                    readonly CLOSING: "CLOSING";
-                    readonly PLACEHOLDER: "PLACEHOLDER";
-                }>;
-                value: z.ZodString;
-                attributes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                parser: z.ZodDefault<z.ZodLiteral<"okapi">>;
-            }, z.core.$strip>>>>;
-            hasBeenSegmented: z.ZodBoolean;
-            segments: z.ZodArray<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>, z.ZodObject<{
-        id: z.ZodString;
-        isTranslatable: z.ZodBoolean;
-        name: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        type: z.ZodOptional<z.ZodString>;
-        skeleton: z.ZodOptional<z.ZodString>;
-        targets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
-            isPlural: z.ZodLiteral<false>;
-            source: z.ZodObject<{
-                hasBeenSegmented: z.ZodBoolean;
-                segments: z.ZodArray<z.ZodString>;
-                metadata: z.ZodOptional<z.ZodObject<{
-                    xcstrings: z.ZodOptional<z.ZodObject<{
-                        state: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    }, z.core.$strip>>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>;
-        }, z.core.$strip>, z.ZodObject<{
-            isPlural: z.ZodLiteral<true>;
-            pluralForms: z.ZodRecord<z.ZodString, z.ZodObject<{
-                hasBeenSegmented: z.ZodBoolean;
-                segments: z.ZodArray<z.ZodString>;
-                metadata: z.ZodOptional<z.ZodObject<{
-                    xcstrings: z.ZodOptional<z.ZodObject<{
-                        state: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    }, z.core.$strip>>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>], "isPlural">>>;
-        metadata: z.ZodOptional<z.ZodObject<{
-            pptxAttributes: z.ZodOptional<z.ZodObject<{
-                slideNumber: z.ZodNumber;
-                slideType: z.ZodEnum<{
-                    readonly LAYOUT: "LAYOUT";
-                    readonly NOTES: "NOTES";
-                    readonly MASTER_NOTES: "MASTER_NOTES";
-                    readonly SLIDE: "SLIDE";
-                    readonly MASTER_SLIDE: "MASTER_SLIDE";
-                    readonly CHART: "CHART";
-                    readonly UNKNOWN: "UNKNOWN";
-                }>;
-            }, z.core.$strip>>;
-            xcstrings: z.ZodOptional<z.ZodObject<{
-                state: z.ZodOptional<z.ZodString>;
-                shouldTranslate: z.ZodOptional<z.ZodBoolean>;
-                extractionState: z.ZodOptional<z.ZodString>;
-                localizationType: z.ZodOptional<z.ZodEnum<{
-                    readonly STRING_UNIT: "STRING_UNIT";
-                    readonly SUBSTITUTIONS: "SUBSTITUTIONS";
-                    readonly PLURAL_VARIATIONS: "PLURAL_VARIATIONS";
-                    readonly DEVICE_VARIATION: "DEVICE_VARIATION";
-                    readonly DEVICE_PLURAL_VARIATION: "DEVICE_PLURAL_VARIATION";
-                }>>;
-                keyPath: z.ZodOptional<z.ZodString>;
-                device: z.ZodOptional<z.ZodEnum<{
-                    readonly MAC: "MAC";
-                    readonly IPHONE: "IPHONE";
-                    readonly APPLE_WATCH: "APPLE_WATCH";
-                    readonly IPAD: "IPAD";
-                    readonly OTHER: "OTHER";
-                }>>;
-                pluralForm: z.ZodOptional<z.ZodEnum<{
-                    readonly ZERO: "ZERO";
-                    readonly ONE: "ONE";
-                    readonly TWO: "TWO";
-                    readonly FEW: "FEW";
-                    readonly MANY: "MANY";
-                    readonly OTHER: "OTHER";
-                }>>;
-                formatSpecifier: z.ZodOptional<z.ZodString>;
-                argNum: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-        isPlural: z.ZodLiteral<false>;
-        source: z.ZodObject<{
-            textCodes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                type: z.ZodEnum<{
-                    readonly OPENING: "OPENING";
-                    readonly CLOSING: "CLOSING";
-                    readonly PLACEHOLDER: "PLACEHOLDER";
-                }>;
-                value: z.ZodString;
-                attributes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                parser: z.ZodDefault<z.ZodLiteral<"okapi">>;
-            }, z.core.$strip>>>>;
-            hasBeenSegmented: z.ZodBoolean;
-            segments: z.ZodArray<z.ZodString>;
-        }, z.core.$strip>;
-    }, z.core.$strip>], "isPlural">>>;
-    position: z.ZodNumber;
-}, z.core.$strip>;
-export declare const RAW_CONTENT_ITEM_SCHEMA: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodOptional<z.ZodString>;
-    priority: z.ZodNumber;
-    contentUnits: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        type: z.ZodEnum<{
-            readonly HTML_FILE: "HTML_FILE";
-            readonly DOCX_FILE: "DOCX_FILE";
-            readonly PPTX_FILE: "PPTX_FILE";
-            readonly XLSX_FILE: "XLSX_FILE";
-            readonly MARKDOWN_FILE: "MARKDOWN_FILE";
-            readonly IDML_FILE: "IDML_FILE";
-            readonly JSON_FILE: "JSON_FILE";
-            readonly YAML_FILE: "YAML_FILE";
-            readonly XCSTRINGS_FILE: "XCSTRINGS_FILE";
-            readonly TEXT: "TEXT";
-            readonly HTML: "HTML";
-            readonly JSON: "JSON";
-            readonly CONTENTFUL_RICH_TEXT: "CONTENTFUL_RICH_TEXT";
-        }>;
-        source: z.ZodUnion<readonly [z.ZodObject<{
-            type: z.ZodLiteral<"inline">;
-            value: z.ZodString;
-            storageId: z.ZodOptional<z.ZodNever>;
-        }, z.core.$strip>, z.ZodObject<{
-            type: z.ZodLiteral<"remote">;
-            storageId: z.ZodString;
-            contentSize: z.ZodOptional<z.ZodString>;
-            filePath: z.ZodOptional<z.ZodString>;
-            value: z.ZodOptional<z.ZodNever>;
-        }, z.core.$strip>]>;
-        context: z.ZodOptional<z.ZodString>;
-        characterLimit: z.ZodOptional<z.ZodNumber>;
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    }, z.core.$strip>>;
-    categoryHierarchy: z.ZodArray<z.ZodString>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
-export declare const PARSED_CONTENT_ITEM_SCHEMA: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodOptional<z.ZodString>;
-    priority: z.ZodNumber;
-    categoryHierarchy: z.ZodArray<z.ZodString>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    contentUnits: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        type: z.ZodEnum<{
-            readonly HTML_FILE: "HTML_FILE";
-            readonly DOCX_FILE: "DOCX_FILE";
-            readonly PPTX_FILE: "PPTX_FILE";
-            readonly XLSX_FILE: "XLSX_FILE";
-            readonly MARKDOWN_FILE: "MARKDOWN_FILE";
-            readonly IDML_FILE: "IDML_FILE";
-            readonly JSON_FILE: "JSON_FILE";
-            readonly YAML_FILE: "YAML_FILE";
-            readonly XCSTRINGS_FILE: "XCSTRINGS_FILE";
-            readonly TEXT: "TEXT";
-            readonly HTML: "HTML";
-            readonly JSON: "JSON";
-            readonly CONTENTFUL_RICH_TEXT: "CONTENTFUL_RICH_TEXT";
-        }>;
-        context: z.ZodOptional<z.ZodString>;
-        characterLimit: z.ZodOptional<z.ZodNumber>;
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-        source: z.ZodUnion<readonly [z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
-            type: z.ZodLiteral<"inline">;
-            value: z.ZodString;
-            storageId: z.ZodOptional<z.ZodNever>;
-        }, z.core.$strip>, z.ZodObject<{
-            type: z.ZodLiteral<"remote">;
-            storageId: z.ZodString;
-            contentSize: z.ZodOptional<z.ZodString>;
-            filePath: z.ZodOptional<z.ZodString>;
-            value: z.ZodOptional<z.ZodNever>;
-        }, z.core.$strip>]>]>;
-        sourceWordCount: z.ZodNumber;
-        textUnits: z.ZodArray<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-            id: z.ZodString;
-            isTranslatable: z.ZodBoolean;
-            name: z.ZodOptional<z.ZodString>;
-            description: z.ZodOptional<z.ZodString>;
-            type: z.ZodOptional<z.ZodString>;
-            skeleton: z.ZodOptional<z.ZodString>;
-            targets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
-                isPlural: z.ZodLiteral<false>;
-                source: z.ZodObject<{
-                    hasBeenSegmented: z.ZodBoolean;
-                    segments: z.ZodArray<z.ZodString>;
-                    metadata: z.ZodOptional<z.ZodObject<{
-                        xcstrings: z.ZodOptional<z.ZodObject<{
-                            state: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                        }, z.core.$strip>>;
-                    }, z.core.$strip>>;
-                }, z.core.$strip>;
-            }, z.core.$strip>, z.ZodObject<{
-                isPlural: z.ZodLiteral<true>;
-                pluralForms: z.ZodRecord<z.ZodString, z.ZodObject<{
-                    hasBeenSegmented: z.ZodBoolean;
-                    segments: z.ZodArray<z.ZodString>;
-                    metadata: z.ZodOptional<z.ZodObject<{
-                        xcstrings: z.ZodOptional<z.ZodObject<{
-                            state: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                        }, z.core.$strip>>;
-                    }, z.core.$strip>>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>], "isPlural">>>;
-            metadata: z.ZodOptional<z.ZodObject<{
-                pptxAttributes: z.ZodOptional<z.ZodObject<{
-                    slideNumber: z.ZodNumber;
-                    slideType: z.ZodEnum<{
-                        readonly LAYOUT: "LAYOUT";
-                        readonly NOTES: "NOTES";
-                        readonly MASTER_NOTES: "MASTER_NOTES";
-                        readonly SLIDE: "SLIDE";
-                        readonly MASTER_SLIDE: "MASTER_SLIDE";
-                        readonly CHART: "CHART";
-                        readonly UNKNOWN: "UNKNOWN";
-                    }>;
-                }, z.core.$strip>>;
-                xcstrings: z.ZodOptional<z.ZodObject<{
-                    state: z.ZodOptional<z.ZodString>;
-                    shouldTranslate: z.ZodOptional<z.ZodBoolean>;
-                    extractionState: z.ZodOptional<z.ZodString>;
-                    localizationType: z.ZodOptional<z.ZodEnum<{
-                        readonly STRING_UNIT: "STRING_UNIT";
-                        readonly SUBSTITUTIONS: "SUBSTITUTIONS";
-                        readonly PLURAL_VARIATIONS: "PLURAL_VARIATIONS";
-                        readonly DEVICE_VARIATION: "DEVICE_VARIATION";
-                        readonly DEVICE_PLURAL_VARIATION: "DEVICE_PLURAL_VARIATION";
-                    }>>;
-                    keyPath: z.ZodOptional<z.ZodString>;
-                    device: z.ZodOptional<z.ZodEnum<{
-                        readonly MAC: "MAC";
-                        readonly IPHONE: "IPHONE";
-                        readonly APPLE_WATCH: "APPLE_WATCH";
-                        readonly IPAD: "IPAD";
-                        readonly OTHER: "OTHER";
-                    }>>;
-                    pluralForm: z.ZodOptional<z.ZodEnum<{
-                        readonly ZERO: "ZERO";
-                        readonly ONE: "ONE";
-                        readonly TWO: "TWO";
-                        readonly FEW: "FEW";
-                        readonly MANY: "MANY";
-                        readonly OTHER: "OTHER";
-                    }>>;
-                    formatSpecifier: z.ZodOptional<z.ZodString>;
-                    argNum: z.ZodOptional<z.ZodNumber>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>>;
-            isPlural: z.ZodLiteral<true>;
-            pluralForms: z.ZodRecord<z.ZodString, z.ZodObject<{
-                textCodes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
-                    id: z.ZodString;
-                    type: z.ZodEnum<{
-                        readonly OPENING: "OPENING";
-                        readonly CLOSING: "CLOSING";
-                        readonly PLACEHOLDER: "PLACEHOLDER";
-                    }>;
-                    value: z.ZodString;
-                    attributes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    parser: z.ZodDefault<z.ZodLiteral<"okapi">>;
-                }, z.core.$strip>>>>;
-                hasBeenSegmented: z.ZodBoolean;
-                segments: z.ZodArray<z.ZodString>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>, z.ZodObject<{
-            id: z.ZodString;
-            isTranslatable: z.ZodBoolean;
-            name: z.ZodOptional<z.ZodString>;
-            description: z.ZodOptional<z.ZodString>;
-            type: z.ZodOptional<z.ZodString>;
-            skeleton: z.ZodOptional<z.ZodString>;
-            targets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
-                isPlural: z.ZodLiteral<false>;
-                source: z.ZodObject<{
-                    hasBeenSegmented: z.ZodBoolean;
-                    segments: z.ZodArray<z.ZodString>;
-                    metadata: z.ZodOptional<z.ZodObject<{
-                        xcstrings: z.ZodOptional<z.ZodObject<{
-                            state: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                        }, z.core.$strip>>;
-                    }, z.core.$strip>>;
-                }, z.core.$strip>;
-            }, z.core.$strip>, z.ZodObject<{
-                isPlural: z.ZodLiteral<true>;
-                pluralForms: z.ZodRecord<z.ZodString, z.ZodObject<{
-                    hasBeenSegmented: z.ZodBoolean;
-                    segments: z.ZodArray<z.ZodString>;
-                    metadata: z.ZodOptional<z.ZodObject<{
-                        xcstrings: z.ZodOptional<z.ZodObject<{
-                            state: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                        }, z.core.$strip>>;
-                    }, z.core.$strip>>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>], "isPlural">>>;
-            metadata: z.ZodOptional<z.ZodObject<{
-                pptxAttributes: z.ZodOptional<z.ZodObject<{
-                    slideNumber: z.ZodNumber;
-                    slideType: z.ZodEnum<{
-                        readonly LAYOUT: "LAYOUT";
-                        readonly NOTES: "NOTES";
-                        readonly MASTER_NOTES: "MASTER_NOTES";
-                        readonly SLIDE: "SLIDE";
-                        readonly MASTER_SLIDE: "MASTER_SLIDE";
-                        readonly CHART: "CHART";
-                        readonly UNKNOWN: "UNKNOWN";
-                    }>;
-                }, z.core.$strip>>;
-                xcstrings: z.ZodOptional<z.ZodObject<{
-                    state: z.ZodOptional<z.ZodString>;
-                    shouldTranslate: z.ZodOptional<z.ZodBoolean>;
-                    extractionState: z.ZodOptional<z.ZodString>;
-                    localizationType: z.ZodOptional<z.ZodEnum<{
-                        readonly STRING_UNIT: "STRING_UNIT";
-                        readonly SUBSTITUTIONS: "SUBSTITUTIONS";
-                        readonly PLURAL_VARIATIONS: "PLURAL_VARIATIONS";
-                        readonly DEVICE_VARIATION: "DEVICE_VARIATION";
-                        readonly DEVICE_PLURAL_VARIATION: "DEVICE_PLURAL_VARIATION";
-                    }>>;
-                    keyPath: z.ZodOptional<z.ZodString>;
-                    device: z.ZodOptional<z.ZodEnum<{
-                        readonly MAC: "MAC";
-                        readonly IPHONE: "IPHONE";
-                        readonly APPLE_WATCH: "APPLE_WATCH";
-                        readonly IPAD: "IPAD";
-                        readonly OTHER: "OTHER";
-                    }>>;
-                    pluralForm: z.ZodOptional<z.ZodEnum<{
-                        readonly ZERO: "ZERO";
-                        readonly ONE: "ONE";
-                        readonly TWO: "TWO";
-                        readonly FEW: "FEW";
-                        readonly MANY: "MANY";
-                        readonly OTHER: "OTHER";
-                    }>>;
-                    formatSpecifier: z.ZodOptional<z.ZodString>;
-                    argNum: z.ZodOptional<z.ZodNumber>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>>;
-            isPlural: z.ZodLiteral<false>;
-            source: z.ZodObject<{
-                textCodes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
-                    id: z.ZodString;
-                    type: z.ZodEnum<{
-                        readonly OPENING: "OPENING";
-                        readonly CLOSING: "CLOSING";
-                        readonly PLACEHOLDER: "PLACEHOLDER";
-                    }>;
-                    value: z.ZodString;
-                    attributes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    parser: z.ZodDefault<z.ZodLiteral<"okapi">>;
-                }, z.core.$strip>>>>;
-                hasBeenSegmented: z.ZodBoolean;
-                segments: z.ZodArray<z.ZodString>;
-            }, z.core.$strip>;
-        }, z.core.$strip>], "isPlural">>>;
-        position: z.ZodNumber;
-    }, z.core.$strip>>;
-    failedContentUnits: z.ZodArray<z.ZodObject<{
-        error: z.ZodString;
-        rawContentUnit: z.ZodObject<{
-            id: z.ZodString;
-            type: z.ZodEnum<{
-                readonly HTML_FILE: "HTML_FILE";
-                readonly DOCX_FILE: "DOCX_FILE";
-                readonly PPTX_FILE: "PPTX_FILE";
-                readonly XLSX_FILE: "XLSX_FILE";
-                readonly MARKDOWN_FILE: "MARKDOWN_FILE";
-                readonly IDML_FILE: "IDML_FILE";
-                readonly JSON_FILE: "JSON_FILE";
-                readonly YAML_FILE: "YAML_FILE";
-                readonly XCSTRINGS_FILE: "XCSTRINGS_FILE";
-                readonly TEXT: "TEXT";
-                readonly HTML: "HTML";
-                readonly JSON: "JSON";
-                readonly CONTENTFUL_RICH_TEXT: "CONTENTFUL_RICH_TEXT";
-            }>;
-            source: z.ZodUnion<readonly [z.ZodObject<{
-                type: z.ZodLiteral<"inline">;
-                value: z.ZodString;
-                storageId: z.ZodOptional<z.ZodNever>;
-            }, z.core.$strip>, z.ZodObject<{
-                type: z.ZodLiteral<"remote">;
-                storageId: z.ZodString;
-                contentSize: z.ZodOptional<z.ZodString>;
-                filePath: z.ZodOptional<z.ZodString>;
-                value: z.ZodOptional<z.ZodNever>;
-            }, z.core.$strip>]>;
-            context: z.ZodOptional<z.ZodString>;
-            characterLimit: z.ZodOptional<z.ZodNumber>;
-            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-        }, z.core.$strip>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type RawContentItem = z.infer<typeof RAW_CONTENT_ITEM_SCHEMA>;
-export type RawContentUnit = z.infer<typeof RAW_CONTENT_UNIT_SCHEMA>;
-export type ParsedContentUnitMetadata = z.infer<typeof PARSED_CONTENT_UNIT_METADATA_SCHEMA>;
-export type ParsedContentItem = z.infer<typeof PARSED_CONTENT_ITEM_SCHEMA>;
-export type ParsedContentUnit = z.infer<typeof PARSED_CONTENT_UNIT_SCHEMA>;
-//# sourceMappingURL=contentObjects.d.ts.map

package/dist/api/contentObjects.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contentObjects.d.ts","sourceRoot":"","sources":["../../src/api/contentObjects.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BlC,CAAA;AAEF,eAAO,MAAM,mCAAmC;;;;;iBAO9C,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKrC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BlC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUG,CAAA;AAE1C,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACpE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACpE,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC3F,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAC1E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA"}

package/dist/api/contentObjects.js

@@ -1,93 +0,0 @@
-/**
- * This file contains schemas for content-related objects.
- *
- * A Content Item is a piece of generic content that can be imported and handled by the system.
- * It consists of content units, which are the smallest parts of the content that a user can manipulate (import, export).
- *
- * When parsed, each content unit is split into text units, which represent the individual pieces of text that can be translated.
- * Each text unit can be further segmented into segments (e.g., individual sentences).
- * Users cannot manipulate text units or segments directly (e.g., remove or add them, otherwise, the system won't be able to
- * reconstruct the content unit properly), but they should be able to influence the text unit extraction process or segmentation rules.
- *
- * In the context of Shopify, a Product would correspond to a Content Item.
- * Two properties of the product, "title" and "description," would be the content units.
- * "title" would be regular text (example: "Premium Cotton T-Shirt"), a single sentence, so it will consist of a single text unit and a single segment.
- * "description" would be HTML content (example: <h1>Product Overview</h1><p>This is a premium cotton t-shirt. It is available in multiple colors.</p>),
- * so it will consist of two text units: one for the <h1> element and another for the <p> element.
- * The <p> element's text unit will contain two segments because it has two sentences.
- *
- * RawContentItem represents the content item before parsing, while ParsedContentItem represents the content item after parsing.
- */
-import { ContentUnitTypeEnum } from '@lokalise/common-api-schemas';
-import { z } from 'zod';
-import { CONTENT_UNIT_SOURCE } from "./contentObjectsNew.js";
-import { TEXT_UNIT } from "./textUnit.js";
-export const RAW_CONTENT_UNIT_SCHEMA = z.object({
-    id: z
-        .string()
-        .min(1)
-        .describe('Identifier of the unit, unique across other contentUnits belonging to a single item, usually human-readable, e.g. "welcome_message" or "header.welcome_message.title".'),
-    type: z
-        .enum(ContentUnitTypeEnum)
-        .describe('The type of content, which may determine requirements for processing, storage, or display.'),
-    source: CONTENT_UNIT_SOURCE,
-    context: z
-        .string()
-        .optional()
-        .describe('Optional context providing additional information about the content.'),
-    characterLimit: z
-        .number()
-        .positive()
-        .optional()
-        .describe('Optional maximum number of characters allowed for the content unit.'),
-    metadata: z
-        .record(z.string(), z.any())
-        .optional()
-        .describe('Optional metadata associated with the content unit.'),
-});
-export const PARSED_CONTENT_UNIT_METADATA_SCHEMA = z.object({
-    pptxAttributes: z
-        .object({
-        slideNumber: z.number(),
-        slideType: z.string(),
-    })
-        .describe('PPTX-specific attributes of the content unit.'),
-});
-export const PARSED_CONTENT_UNIT_SCHEMA = RAW_CONTENT_UNIT_SCHEMA.extend({
-    source: z.union([z.string(), CONTENT_UNIT_SOURCE]),
-    sourceWordCount: z.number().gte(0).describe('The total word count of the source text.'),
-    textUnits: TEXT_UNIT.array().describe('The text units extracted from the content unit.'),
-    position: z.number().int().nonnegative(), // >= 0
-});
-export const RAW_CONTENT_ITEM_SCHEMA = z.object({
-    id: z
-        .string()
-        .min(1)
-        .describe('Identifier of the item, unique across other items belonging to a single project.'),
-    name: z
-        .string()
-        .min(1)
-        .max(256)
-        .optional()
-        .describe('Human-readable name of the item. Maximum length is dictated by TSS item name limit.'),
-    priority: z
-        .number()
-        .min(0)
-        .describe("Number indicating how important it is to have this item translated in user's store. It is relevant in case not all items fit within the user's current limit defined by their subscription plan. The higher the number, the higher the priority, and so the more likely the item is to be translated."),
-    contentUnits: RAW_CONTENT_UNIT_SCHEMA.array(),
-    categoryHierarchy: z.array(z.string()).refine((data) => {
-        const set = new Set(data);
-        return set.size === data.length;
-    }, 'Category names must be unique'),
-    metadata: z.record(z.string(), z.unknown()).optional(),
-});
-export const PARSED_CONTENT_ITEM_SCHEMA = RAW_CONTENT_ITEM_SCHEMA.extend({
-    contentUnits: PARSED_CONTENT_UNIT_SCHEMA.array(),
-    failedContentUnits: z
-        .array(z.object({
-        error: z.string().describe('Error message.'),
-        rawContentUnit: RAW_CONTENT_UNIT_SCHEMA,
-    }))
-        .describe('Content units that failed to be parsed.'),
-}).describe('Content item after parsing.');
-//# sourceMappingURL=contentObjects.js.map