@lokalise/content-conversion-schemas 1.0.0

package/README.md

@@ -0,0 +1,3 @@
+# In-and-out events schemas
+
+This library contains schemas and types related to in-and-out workflow events.

package/dist/api/contentObjects.d.ts

@@ -0,0 +1,448 @@
+/**
+ * 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 TEXT_SEGMENT_SCHEMA: z.ZodString;
+export declare const TEXT_UNIT_SCHEMA: z.ZodObject<{
+    id: z.ZodString;
+    source: z.ZodObject<{
+        hasBeenSegmented: z.ZodBoolean;
+        segments: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        hasBeenSegmented: boolean;
+        segments: string[];
+    }, {
+        hasBeenSegmented: boolean;
+        segments: string[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    source: {
+        hasBeenSegmented: boolean;
+        segments: string[];
+    };
+}, {
+    id: string;
+    source: {
+        hasBeenSegmented: boolean;
+        segments: string[];
+    };
+}>;
+export declare const RAW_CONTENT_UNIT_SCHEMA: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodNativeEnum<{
+        readonly TEXT: "TEXT";
+        readonly HTML: "HTML";
+        readonly JSON: "JSON";
+        readonly CONTENTFUL_RICH_TEXT: "CONTENTFUL_RICH_TEXT";
+    }>;
+    source: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    characterLimit: z.ZodOptional<z.ZodNumber>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "TEXT" | "HTML" | "JSON" | "CONTENTFUL_RICH_TEXT";
+    source: string;
+    context?: string | undefined;
+    characterLimit?: number | undefined;
+    metadata?: Record<string, any> | undefined;
+}, {
+    id: string;
+    type: "TEXT" | "HTML" | "JSON" | "CONTENTFUL_RICH_TEXT";
+    source: string;
+    context?: string | undefined;
+    characterLimit?: number | undefined;
+    metadata?: Record<string, any> | undefined;
+}>;
+export declare const PARSED_CONTENT_UNIT_METADATA_SCHEMA: z.ZodObject<{
+    pptxAttributes: z.ZodObject<{
+        slideNumber: z.ZodNumber;
+        slideType: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        slideNumber: number;
+        slideType: string;
+    }, {
+        slideNumber: number;
+        slideType: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    pptxAttributes: {
+        slideNumber: number;
+        slideType: string;
+    };
+}, {
+    pptxAttributes: {
+        slideNumber: number;
+        slideType: string;
+    };
+}>;
+export declare const PARSED_CONTENT_UNIT_SCHEMA: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodNativeEnum<{
+        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.ZodString;
+    sourceWordCount: z.ZodNumber;
+    textUnits: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodObject<{
+            hasBeenSegmented: z.ZodBoolean;
+            segments: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            hasBeenSegmented: boolean;
+            segments: string[];
+        }, {
+            hasBeenSegmented: boolean;
+            segments: string[];
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        source: {
+            hasBeenSegmented: boolean;
+            segments: string[];
+        };
+    }, {
+        id: string;
+        source: {
+            hasBeenSegmented: boolean;
+            segments: string[];
+        };
+    }>, "many">;
+    position: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "TEXT" | "HTML" | "JSON" | "CONTENTFUL_RICH_TEXT";
+    source: string;
+    sourceWordCount: number;
+    textUnits: {
+        id: string;
+        source: {
+            hasBeenSegmented: boolean;
+            segments: string[];
+        };
+    }[];
+    position: number;
+    context?: string | undefined;
+    characterLimit?: number | undefined;
+    metadata?: Record<string, any> | undefined;
+}, {
+    id: string;
+    type: "TEXT" | "HTML" | "JSON" | "CONTENTFUL_RICH_TEXT";
+    source: string;
+    sourceWordCount: number;
+    textUnits: {
+        id: string;
+        source: {
+            hasBeenSegmented: boolean;
+            segments: string[];
+        };
+    }[];
+    position: number;
+    context?: string | undefined;
+    characterLimit?: number | undefined;
+    metadata?: Record<string, any> | undefined;
+}>;
+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.ZodNativeEnum<{
+            readonly TEXT: "TEXT";
+            readonly HTML: "HTML";
+            readonly JSON: "JSON";
+            readonly CONTENTFUL_RICH_TEXT: "CONTENTFUL_RICH_TEXT";
+        }>;
+        source: z.ZodString;
+        context: z.ZodOptional<z.ZodString>;
+        characterLimit: z.ZodOptional<z.ZodNumber>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: "TEXT" | "HTML" | "JSON" | "CONTENTFUL_RICH_TEXT";
+        source: string;
+        context?: string | undefined;
+        characterLimit?: number | undefined;
+        metadata?: Record<string, any> | undefined;
+    }, {
+        id: string;
+        type: "TEXT" | "HTML" | "JSON" | "CONTENTFUL_RICH_TEXT";
+        source: string;
+        context?: string | undefined;
+        characterLimit?: number | undefined;
+        metadata?: Record<string, any> | undefined;
+    }>, "many">;
+    categoryHierarchy: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+    origin: z.ZodNativeEnum<{
+        readonly SHOPIFY: "SHOPIFY";
+    }>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    priority: number;
+    contentUnits: {
+        id: string;
+        type: "TEXT" | "HTML" | "JSON" | "CONTENTFUL_RICH_TEXT";
+        source: string;
+        context?: string | undefined;
+        characterLimit?: number | undefined;
+        metadata?: Record<string, any> | undefined;
+    }[];
+    categoryHierarchy: string[];
+    origin: "SHOPIFY";
+    name?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    id: string;
+    priority: number;
+    contentUnits: {
+        id: string;
+        type: "TEXT" | "HTML" | "JSON" | "CONTENTFUL_RICH_TEXT";
+        source: string;
+        context?: string | undefined;
+        characterLimit?: number | undefined;
+        metadata?: Record<string, any> | undefined;
+    }[];
+    categoryHierarchy: string[];
+    origin: "SHOPIFY";
+    name?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+export declare const PARSED_CONTENT_ITEM_SCHEMA: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    priority: z.ZodNumber;
+    categoryHierarchy: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+    origin: z.ZodNativeEnum<{
+        readonly SHOPIFY: "SHOPIFY";
+    }>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    contentUnits: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodNativeEnum<{
+            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.ZodString;
+        sourceWordCount: z.ZodNumber;
+        textUnits: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            source: z.ZodObject<{
+                hasBeenSegmented: z.ZodBoolean;
+                segments: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                hasBeenSegmented: boolean;
+                segments: string[];
+            }, {
+                hasBeenSegmented: boolean;
+                segments: string[];
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            source: {
+                hasBeenSegmented: boolean;
+                segments: string[];
+            };
+        }, {
+            id: string;
+            source: {
+                hasBeenSegmented: boolean;
+                segments: string[];
+            };
+        }>, "many">;
+        position: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: "TEXT" | "HTML" | "JSON" | "CONTENTFUL_RICH_TEXT";
+        source: string;
+        sourceWordCount: number;
+        textUnits: {
+            id: string;
+            source: {
+                hasBeenSegmented: boolean;
+                segments: string[];
+            };
+        }[];
+        position: number;
+        context?: string | undefined;
+        characterLimit?: number | undefined;
+        metadata?: Record<string, any> | undefined;
+    }, {
+        id: string;
+        type: "TEXT" | "HTML" | "JSON" | "CONTENTFUL_RICH_TEXT";
+        source: string;
+        sourceWordCount: number;
+        textUnits: {
+            id: string;
+            source: {
+                hasBeenSegmented: boolean;
+                segments: string[];
+            };
+        }[];
+        position: number;
+        context?: string | undefined;
+        characterLimit?: number | undefined;
+        metadata?: Record<string, any> | undefined;
+    }>, "many">;
+    failedContentUnits: z.ZodArray<z.ZodObject<{
+        error: z.ZodString;
+        rawContentUnit: z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodNativeEnum<{
+                readonly TEXT: "TEXT";
+                readonly HTML: "HTML";
+                readonly JSON: "JSON";
+                readonly CONTENTFUL_RICH_TEXT: "CONTENTFUL_RICH_TEXT";
+            }>;
+            source: z.ZodString;
+            context: z.ZodOptional<z.ZodString>;
+            characterLimit: z.ZodOptional<z.ZodNumber>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            type: "TEXT" | "HTML" | "JSON" | "CONTENTFUL_RICH_TEXT";
+            source: string;
+            context?: string | undefined;
+            characterLimit?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        }, {
+            id: string;
+            type: "TEXT" | "HTML" | "JSON" | "CONTENTFUL_RICH_TEXT";
+            source: string;
+            context?: string | undefined;
+            characterLimit?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        error: string;
+        rawContentUnit: {
+            id: string;
+            type: "TEXT" | "HTML" | "JSON" | "CONTENTFUL_RICH_TEXT";
+            source: string;
+            context?: string | undefined;
+            characterLimit?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        };
+    }, {
+        error: string;
+        rawContentUnit: {
+            id: string;
+            type: "TEXT" | "HTML" | "JSON" | "CONTENTFUL_RICH_TEXT";
+            source: string;
+            context?: string | undefined;
+            characterLimit?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        };
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    priority: number;
+    contentUnits: {
+        id: string;
+        type: "TEXT" | "HTML" | "JSON" | "CONTENTFUL_RICH_TEXT";
+        source: string;
+        sourceWordCount: number;
+        textUnits: {
+            id: string;
+            source: {
+                hasBeenSegmented: boolean;
+                segments: string[];
+            };
+        }[];
+        position: number;
+        context?: string | undefined;
+        characterLimit?: number | undefined;
+        metadata?: Record<string, any> | undefined;
+    }[];
+    categoryHierarchy: string[];
+    origin: "SHOPIFY";
+    failedContentUnits: {
+        error: string;
+        rawContentUnit: {
+            id: string;
+            type: "TEXT" | "HTML" | "JSON" | "CONTENTFUL_RICH_TEXT";
+            source: string;
+            context?: string | undefined;
+            characterLimit?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        };
+    }[];
+    name?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    id: string;
+    priority: number;
+    contentUnits: {
+        id: string;
+        type: "TEXT" | "HTML" | "JSON" | "CONTENTFUL_RICH_TEXT";
+        source: string;
+        sourceWordCount: number;
+        textUnits: {
+            id: string;
+            source: {
+                hasBeenSegmented: boolean;
+                segments: string[];
+            };
+        }[];
+        position: number;
+        context?: string | undefined;
+        characterLimit?: number | undefined;
+        metadata?: Record<string, any> | undefined;
+    }[];
+    categoryHierarchy: string[];
+    origin: "SHOPIFY";
+    failedContentUnits: {
+        error: string;
+        rawContentUnit: {
+            id: string;
+            type: "TEXT" | "HTML" | "JSON" | "CONTENTFUL_RICH_TEXT";
+            source: string;
+            context?: string | undefined;
+            characterLimit?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        };
+    }[];
+    name?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+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>;
+export type TextUnit = z.infer<typeof TEXT_UNIT_SCHEMA>;
+export type TextSegment = z.infer<typeof TEXT_SEGMENT_SCHEMA>;
+//# sourceMappingURL=contentObjects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contentObjects.d.ts","sourceRoot":"","sources":["../../src/api/contentObjects.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,mBAAmB,aAI/B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;EAc1B,CAAA;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BlC,CAAA;AAEF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;EAO9C,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKrC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BlC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUG,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;AAC1E,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AACvD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/api/contentObjects.js

@@ -0,0 +1,106 @@
+/**
+ * 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';
+import { ContentUnitTypeEnum, ItemOriginEnum } from './enums.js';
+export const TEXT_SEGMENT_SCHEMA = z.string().describe(`Represents a text segment, a smaller part of a larger text. 
+Segments are created through segmentation, where a text is broken down into smaller units, such as sentences, 
+to facilitate operations like translation and leveraging translation memory.`);
+export const TEXT_UNIT_SCHEMA = z
+    .object({
+    id: z.string().min(1).describe('Unique identifier of the text unit within a content unit.'),
+    source: z.object({
+        hasBeenSegmented: z
+            .boolean()
+            .describe('Indicates whether the segmentation was applied to the text unit.'),
+        segments: TEXT_SEGMENT_SCHEMA.array().describe('The text parts that make up the text unit. If the text unit has not been segmented, the array will contain a single segment.'),
+    }),
+})
+    .describe('Represents a text unit, the basic unit of extraction from a parser. May be split further into segments.');
+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
+        .nativeEnum(ContentUnitTypeEnum)
+        .describe('The type of content, which may determine requirements for processing, storage, or display.'),
+    source: z.string().describe('The source text of the unit.'),
+    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.string().describe('The source text of the unit.'),
+    sourceWordCount: z.number().gte(0).describe('The total word count of the source text.'),
+    textUnits: TEXT_UNIT_SCHEMA.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'),
+    origin: z.nativeEnum(ItemOriginEnum).describe('Source the item was got from.'),
+    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

package/dist/api/contentObjects.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contentObjects.js","sourceRoot":"","sources":["../../src/api/contentObjects.ts"],"names":[],"mappings":"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"}

package/dist/api/enums.d.ts

@@ -0,0 +1,32 @@
+export type ObjectValues<T> = T[keyof T];
+export declare const ItemTypeEnum: {
+    readonly FILE: "FILE";
+    readonly GENERIC_CONTENT_ITEM: "GENERIC_CONTENT_ITEM";
+};
+export type ItemType = ObjectValues<typeof ItemTypeEnum>;
+export declare const ItemOriginEnum: {
+    readonly SHOPIFY: "SHOPIFY";
+};
+export type ItemOrigin = ObjectValues<typeof ItemOriginEnum>;
+export declare const ContentUnitTypeEnum: {
+    readonly TEXT: "TEXT";
+    readonly HTML: "HTML";
+    readonly JSON: "JSON";
+    readonly CONTENTFUL_RICH_TEXT: "CONTENTFUL_RICH_TEXT";
+};
+export type ContentUnitType = ObjectValues<typeof ContentUnitTypeEnum>;
+export declare const OutputTypeEnum: {
+    readonly FILE: "FILE";
+    readonly GIT: "GIT";
+    readonly SHOPIFY: "SHOPIFY";
+};
+export type OutputType = ObjectValues<typeof OutputTypeEnum>;
+export declare const SegmentStatusEnum: {
+    readonly TRANSLATING: "TRANSLATING";
+    readonly TRANSLATION_FAILED: "TRANSLATION_FAILED";
+    readonly LQA_IN_PROGRESS: "LQA_IN_PROGRESS";
+    readonly PENDING_REVIEW: "PENDING_REVIEW";
+    readonly APPROVED: "APPROVED";
+};
+export type SegmentStatus = ObjectValues<typeof SegmentStatusEnum>;
+//# sourceMappingURL=enums.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"enums.d.ts","sourceRoot":"","sources":["../../src/api/enums.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAA;AAExC,eAAO,MAAM,YAAY;;;CAGf,CAAA;AACV,MAAM,MAAM,QAAQ,GAAG,YAAY,CAAC,OAAO,YAAY,CAAC,CAAA;AAExD,eAAO,MAAM,cAAc;;CAEjB,CAAA;AACV,MAAM,MAAM,UAAU,GAAG,YAAY,CAAC,OAAO,cAAc,CAAC,CAAA;AAE5D,eAAO,MAAM,mBAAmB;;;;;CAKtB,CAAA;AACV,MAAM,MAAM,eAAe,GAAG,YAAY,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAEtE,eAAO,MAAM,cAAc;;;;CAIjB,CAAA;AACV,MAAM,MAAM,UAAU,GAAG,YAAY,CAAC,OAAO,cAAc,CAAC,CAAA;AAE5D,eAAO,MAAM,iBAAiB;;;;;;CAMpB,CAAA;AACV,MAAM,MAAM,aAAa,GAAG,YAAY,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/api/enums.js

@@ -0,0 +1,26 @@
+export const ItemTypeEnum = {
+    FILE: 'FILE',
+    GENERIC_CONTENT_ITEM: 'GENERIC_CONTENT_ITEM',
+};
+export const ItemOriginEnum = {
+    SHOPIFY: 'SHOPIFY',
+};
+export const ContentUnitTypeEnum = {
+    TEXT: 'TEXT',
+    HTML: 'HTML',
+    JSON: 'JSON',
+    CONTENTFUL_RICH_TEXT: 'CONTENTFUL_RICH_TEXT',
+};
+export const OutputTypeEnum = {
+    FILE: 'FILE',
+    GIT: 'GIT',
+    SHOPIFY: 'SHOPIFY',
+};
+export const SegmentStatusEnum = {
+    TRANSLATING: 'TRANSLATING',
+    TRANSLATION_FAILED: 'TRANSLATION_FAILED',
+    LQA_IN_PROGRESS: 'LQA_IN_PROGRESS',
+    PENDING_REVIEW: 'PENDING_REVIEW',
+    APPROVED: 'APPROVED',
+};
+//# sourceMappingURL=enums.js.map

package/dist/api/enums.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.js","sourceRoot":"","sources":["../../src/api/enums.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,MAAM;IACZ,oBAAoB,EAAE,sBAAsB;CACpC,CAAA;AAGV,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,OAAO,EAAE,SAAS;CACV,CAAA;AAGV,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,oBAAoB,EAAE,sBAAsB;CACpC,CAAA;AAGV,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,MAAM;IACZ,GAAG,EAAE,KAAK;IACV,OAAO,EAAE,SAAS;CACV,CAAA;AAGV,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,WAAW,EAAE,aAAa;IAC1B,kBAAkB,EAAE,oBAAoB;IACxC,eAAe,EAAE,iBAAiB;IAClC,cAAc,EAAE,gBAAgB;IAChC,QAAQ,EAAE,UAAU;CACZ,CAAA"}