@shotstack/schemas 1.8.4 → 1.8.6

package/dist/zod/zod.gen.js

@@ -814,7 +814,7 @@ export const akamaiNetStorageDestinationOptionsAkamaiNetStorageDestinationOption
  * Send videos and assets to [Akamai NetStorage](https://techdocs.akamai.com/netstorage-usage/docs). Send files to your NetStorage upload directory with a custom path and filename. Akamai credentials are required and added via the [dashboard](https://dashboard.shotstack.io/integrations/akamai-netstorage), not in the request.
  */
 export const akamaiNetStorageDestinationAkamaiNetStorageDestinationSchema = z.object({
-    provider: z.string().default("akamai-netstorage"),
+    provider: z.literal("akamai-netstorage"),
     options: z.optional(akamaiNetStorageDestinationOptionsAkamaiNetStorageDestinationOptionsSchema),
 }).strict();
 /**
@@ -830,7 +830,7 @@ export const azureBlobStorageDestinationOptionsAzureBlobStorageDestinationOption
  * Send videos and assets to [Azure Blob Storage](https://learn.microsoft.com/en-us/azure/storage/blobs/). Send files to any container with a custom prefix and filename. Azure credentials are required and added via the [dashboard](https://dashboard.shotstack.io/integrations/azure-blob-storage), not in the request.
  */
 export const azureBlobStorageDestinationAzureBlobStorageDestinationSchema = z.object({
-    provider: z.string().default("azure-blob-storage"),
+    provider: z.literal("azure-blob-storage"),
     options: z.optional(azureBlobStorageDestinationOptionsAzureBlobStorageDestinationOptionsSchema),
 }).strict();
 /**
@@ -967,7 +967,9 @@ export const destinationsDestinationsSchema = z.discriminatedUnion("provider", [
     googleCloudStorageDestinationGoogleCloudStorageDestinationSchema,
     googleDriveDestinationGoogleDriveDestinationSchema,
     vimeoDestinationVimeoDestinationSchema,
-    tiktokDestinationTiktokDestinationSchema
+    tiktokDestinationTiktokDestinationSchema,
+    akamaiNetStorageDestinationAkamaiNetStorageDestinationSchema,
+    azureBlobStorageDestinationAzureBlobStorageDestinationSchema
 ]);
 export const destinationsSchema = destinationsDestinationsSchema;
 /**
@@ -2107,23 +2109,612 @@ export const soundtrackSoundtrackSchema = z.object({
 }).strict();
 export const soundtrackSchema = soundtrackSoundtrackSchema;
 /**
- * The SvgAsset is used to create scalable vector graphic (SVG) assets using
- * raw SVG markup.
+ * A color stop in a gradient. Each stop defines a color at a specific position
+ * along the gradient vector. Gradients require at least 2 stops.
  *
+ */
+export const svgpropertiesSvgGradientStopSchema = z.object({
+    offset: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(0).lte(1)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+    color: z.union([z.string().regex(/^#[A-Fa-f0-9]{6}$/), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+}).strict();
+export const svgGradientStopSchema = svgpropertiesSvgGradientStopSchema;
+/**
+ * A linear gradient fill that transitions colors along a straight line.
+ * The gradient direction is controlled by the `angle` property.
+ *
+ */
+export const svgpropertiesSvgLinearGradientFillSchema = z.object({
+    type: z.enum(["linear"]),
+    angle: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(0).lte(360)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default(0),
+    stops: z.array(svgpropertiesSvgGradientStopSchema).min(2),
+    opacity: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(0).lte(1)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default(1),
+}).strict();
+export const svgLinearGradientFillSchema = svgpropertiesSvgLinearGradientFillSchema;
+/**
+ * A radial gradient fill that transitions colors radiating outward from a center point.
+ * The gradient creates a circular or elliptical color transition.
+ *
+ */
+export const svgpropertiesSvgRadialGradientFillSchema = z.object({
+    type: z.enum(["radial"]),
+    stops: z.array(svgpropertiesSvgGradientStopSchema).min(2),
+    opacity: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(0).lte(1)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default(1),
+}).strict();
+export const svgRadialGradientFillSchema = svgpropertiesSvgRadialGradientFillSchema;
+/**
+ * Drop shadow properties for SVG shapes. Creates a shadow effect behind the shape.
+ *
+ */
+export const svgpropertiesSvgShadowSchema = z.object({
+    offsetX: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number()), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default(0),
+    offsetY: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number()), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default(0),
+    blur: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(0)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default(0),
+    color: z.optional(z.union([z.string().regex(/^#[A-Fa-f0-9]{6}$/), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default("#000000"),
+    opacity: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(0).lte(1)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default(0.5),
+}).strict();
+export const svgShadowSchema = svgpropertiesSvgShadowSchema;
+/**
+ * A solid color fill for SVG shapes.
+ */
+export const svgpropertiesSvgSolidFillSchema = z.object({
+    type: z.enum(["solid"]),
+    color: z
+        .string()
+        .regex(/^#[A-Fa-f0-9]{6}$/)
+        .default("#000000"),
+    opacity: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(0).lte(1)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default(1),
+}).strict();
+export const svgSolidFillSchema = svgpropertiesSvgSolidFillSchema;
+/**
+ * Fill properties for SVG shapes. Supports solid colors and gradients.
+ * The fill defines how the interior of a shape is painted.
+ *
+ */
+export const svgpropertiesSvgFillSchema = z.discriminatedUnion("type", [
+    svgpropertiesSvgSolidFillSchema,
+    svgpropertiesSvgLinearGradientFillSchema,
+    svgpropertiesSvgRadialGradientFillSchema,
+]);
+export const svgFillSchema = svgpropertiesSvgFillSchema;
+/**
+ * Stroke (outline) properties for SVG shapes. The stroke defines how the outline
+ * of a shape is painted, including its color, width, and line style.
+ *
+ */
+export const svgpropertiesSvgStrokeSchema = z.object({
+    color: z.optional(z.union([z.string().regex(/^#[A-Fa-f0-9]{6}$/), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default("#000000"),
+    width: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(0).lte(100)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default(1),
+    opacity: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(0).lte(1)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default(1),
+    lineCap: z.optional(z.enum(["butt", "round", "square"])),
+    lineJoin: z.optional(z.enum(["miter", "round", "bevel"])),
+    dashArray: z.optional(z.array(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(0)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]))),
+    dashOffset: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number()), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default(0),
+}).strict();
+export const svgStrokeSchema = svgpropertiesSvgStrokeSchema;
+/**
+ * Transformation properties for positioning, rotating, and scaling SVG shapes.
+ *
+ */
+export const svgpropertiesSvgTransformSchema = z.object({
+    x: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number()), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default(0),
+    y: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number()), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default(0),
+    rotation: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(-360).lte(360)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default(0),
+    scale: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(0.01).lte(100)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default(1),
+    originX: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(0).lte(1)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default(0.5),
+    originY: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(0).lte(1)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default(0.5),
+}).strict();
+export const svgTransformSchema = svgpropertiesSvgTransformSchema;
+/**
+ * An arrow shape pointing to the right by default.
+ * Use transform rotation to change direction.
+ *
+ */
+export const svgshapesSvgArrowShapeSchema = z.object({
+    type: z.enum(["arrow"]),
+    length: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(1).lte(4096)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+    headWidth: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(1).lte(1000)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+    headLength: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(1).lte(1000)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+    shaftWidth: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(1).lte(1000)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+}).strict();
+export const svgArrowShapeSchema = svgshapesSvgArrowShapeSchema;
+/**
+ * A perfect circle shape defined by its radius.
+ * The circle is centered at the shape's position.
+ *
+ */
+export const svgshapesSvgCircleShapeSchema = z.object({
+    type: z.enum(["circle"]),
+    radius: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(1).lte(2048)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+}).strict();
+export const svgCircleShapeSchema = svgshapesSvgCircleShapeSchema;
+/**
+ * A cross or plus shape with equal or different arm lengths.
+ * Can be styled as a plus sign (+) or a cross (x with rotation).
+ *
+ */
+export const svgshapesSvgCrossShapeSchema = z.object({
+    type: z.enum(["cross"]),
+    width: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(1).lte(4096)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+    height: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(1).lte(4096)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+    thickness: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(1).lte(500)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+}).strict();
+export const svgCrossShapeSchema = svgshapesSvgCrossShapeSchema;
+/**
+ * An ellipse (oval) shape with separate horizontal and vertical radii.
+ * The ellipse is centered at the shape's position.
+ *
+ */
+export const svgshapesSvgEllipseShapeSchema = z.object({
+    type: z.enum(["ellipse"]),
+    radiusX: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(1).lte(2048)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+    radiusY: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(1).lte(2048)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+}).strict();
+export const svgEllipseShapeSchema = svgshapesSvgEllipseShapeSchema;
+/**
+ * A heart shape commonly used for love/like icons.
+ * The heart is defined by a single size parameter.
+ *
+ */
+export const svgshapesSvgHeartShapeSchema = z.object({
+    type: z.enum(["heart"]),
+    size: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(1).lte(4096)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+}).strict();
+export const svgHeartShapeSchema = svgshapesSvgHeartShapeSchema;
+/**
+ * A straight line shape with a specified length and thickness.
+ * The line is drawn horizontally by default and can be rotated using transform.
+ *
+ */
+export const svgshapesSvgLineShapeSchema = z.object({
+    type: z.enum(["line"]),
+    length: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(1).lte(4096)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+    thickness: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(1).lte(500)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+}).strict();
+export const svgLineShapeSchema = svgshapesSvgLineShapeSchema;
+/**
+ * A custom shape defined by SVG path data.
+ * Supports all standard SVG path commands for creating complex shapes.
+ *
+ * **Path Commands:**
+ * - `M x y` / `m dx dy` - Move to (absolute/relative)
+ * - `L x y` / `l dx dy` - Line to
+ * - `H x` / `h dx` - Horizontal line to
+ * - `V y` / `v dy` - Vertical line to
+ * - `C x1 y1 x2 y2 x y` / `c` - Cubic Bezier curve
+ * - `S x2 y2 x y` / `s` - Smooth cubic Bezier
+ * - `Q x1 y1 x y` / `q` - Quadratic Bezier curve
+ * - `T x y` / `t` - Smooth quadratic Bezier
+ * - `A rx ry angle large-arc sweep x y` / `a` - Elliptical arc
+ * - `Z` / `z` - Close path
+ *
+ */
+export const svgshapesSvgPathShapeSchema = z.object({
+    type: z.enum(["path"]),
+    d: z.string().min(1).max(100000),
+}).strict();
+export const svgPathShapeSchema = svgshapesSvgPathShapeSchema;
+/**
+ * A regular polygon shape with a specified number of sides.
+ * Examples: triangle (3), square (4), pentagon (5), hexagon (6), etc.
+ * The polygon is inscribed in a circle of the given radius.
+ *
+ */
+export const svgshapesSvgPolygonShapeSchema = z.object({
+    type: z.enum(["polygon"]),
+    sides: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().int().gte(3).lte(100)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+    radius: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(1).lte(2048)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+}).strict();
+export const svgPolygonShapeSchema = svgshapesSvgPolygonShapeSchema;
+/**
+ * A rectangle shape with optional rounded corners.
+ * The rectangle is defined by its width and height dimensions.
+ *
+ */
+export const svgshapesSvgRectangleShapeSchema = z.object({
+    type: z.enum(["rectangle"]),
+    width: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(1).lte(4096)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+    height: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(1).lte(4096)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+    cornerRadius: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(0).lte(2048)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default(0),
+}).strict();
+export const svgRectangleShapeSchema = svgshapesSvgRectangleShapeSchema;
+/**
+ * A ring (donut/annulus) shape - a circle with a circular hole in the center.
+ * The ring is defined by outer and inner radii.
+ *
+ */
+export const svgshapesSvgRingShapeSchema = z.object({
+    type: z.enum(["ring"]),
+    outerRadius: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(1).lte(2048)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+    innerRadius: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(0).lte(2048)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+}).strict();
+export const svgRingShapeSchema = svgshapesSvgRingShapeSchema;
+/**
+ * A star shape with a specified number of points.
+ * The star is defined by outer and inner radii, creating the characteristic
+ * pointed appearance.
+ *
+ */
+export const svgshapesSvgStarShapeSchema = z.object({
+    type: z.enum(["star"]),
+    points: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().int().gte(3).lte(100)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+    outerRadius: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(1).lte(2048)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+    innerRadius: z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(1).lte(2048)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)]),
+}).strict();
+export const svgStarShapeSchema = svgshapesSvgStarShapeSchema;
+/**
+ * The shape definition for an SVG asset. Each shape type has its own specific
+ * properties. The `type` field determines which shape is rendered.
+ *
+ */
+export const svgshapesSvgShapeSchema = z.discriminatedUnion("type", [
+    svgshapesSvgRectangleShapeSchema,
+    svgshapesSvgCircleShapeSchema,
+    svgshapesSvgEllipseShapeSchema,
+    svgshapesSvgLineShapeSchema,
+    svgshapesSvgPolygonShapeSchema,
+    svgshapesSvgStarShapeSchema,
+    svgshapesSvgArrowShapeSchema,
+    svgshapesSvgHeartShapeSchema,
+    svgshapesSvgCrossShapeSchema,
+    svgshapesSvgRingShapeSchema,
+    svgshapesSvgPathShapeSchema,
+]);
+export const svgShapeSchema = svgshapesSvgShapeSchema;
+/**
+ * The SvgAsset is used to add scalable vector graphics (SVG) shapes to a video.
+ * It provides two mutually exclusive ways to define shapes:
+ *
+ * **Option 1: Import SVG markup using `src`**
  * ```json
  * {
  * "type": "svg",
  * "src": "<svg width=\"100\" height=\"100\"><circle cx=\"50\" cy=\"50\" r=\"40\" fill=\"#FF0000\"/></svg>"
  * }
  * ```
+ * When using `src`, no other properties are allowed. The fill, stroke, and dimensions
+ * are automatically extracted from the SVG markup.
+ *
+ * **Option 2: Define shapes programmatically using `shape`**
+ * ```json
+ * {
+ * "type": "svg",
+ * "shape": { "type": "circle", "radius": 50 },
+ * "fill": { "type": "solid", "color": "#FF0000" }
+ * }
+ * ```
+ * When using `shape`, you can customize fill, stroke, shadow, transform, and other properties.
+ * The `src` property is not allowed in this mode.
+ *
+ * **Important:** You must provide either `src` OR `shape`, but not both.
+ * These two modes are mutually exclusive.
+ *
+ * **Available Shapes (Option 2 only):**
+ * - `rectangle` - Rectangles with optional rounded corners
+ * - `circle` - Perfect circles
+ * - `ellipse` - Ellipses/ovals with separate x and y radii
+ * - `line` - Straight lines with configurable thickness
+ * - `polygon` - Regular polygons (triangle, pentagon, hexagon, etc.)
+ * - `star` - Multi-pointed stars
+ * - `arrow` - Directional arrows
+ * - `heart` - Heart shapes
+ * - `cross` - Plus/cross shapes
+ * - `ring` - Donut/ring shapes
+ * - `path` - Custom shapes using SVG path data
  *
- * See [W3C SVG 2 Specification](https://www.w3.org/TR/SVG2/) for SVG markup syntax.
+ * See [W3C SVG 2 Specification](https://www.w3.org/TR/SVG2/) for path data syntax.
  *
  */
 export const svgassetSvgAssetSchema = z.object({
     type: z.enum(["svg"]),
-    src: z.string().min(1).max(500000),
-}).strict();
+    src: z.optional(z.string().min(1).max(500000)),
+    shape: z.optional(svgshapesSvgShapeSchema),
+    fill: z.optional(svgpropertiesSvgFillSchema),
+    stroke: z.optional(svgpropertiesSvgStrokeSchema),
+    shadow: z.optional(svgpropertiesSvgShadowSchema),
+    transform: z.optional(svgpropertiesSvgTransformSchema),
+    opacity: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().gte(0).lte(1)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])).default(1),
+    width: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().int().gte(1).lte(4096)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])),
+    height: z.optional(z.union([z.preprocess(((v) => { if (v === '' || v === null || v === undefined)
+            return undefined; if (Array.isArray(v))
+            return v; if (typeof v === 'string') {
+            if (/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/.test(v))
+                return v;
+            return Number(v);
+        } return v; }), z.number().int().gte(1).lte(4096)), z.string().regex(/^\{\{\s*[A-Za-z0-9_]+\s*\}\}$/)])),
+}).strict().superRefine((data, ctx) => {
+    const hasShape = data.shape !== undefined;
+    const hasSrc = data.src !== undefined && data.src.trim() !== "";
+    if (!hasShape && !hasSrc) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Either 'src' or 'shape' must be provided",
+            path: [],
+        });
+    }
+    if (hasShape && hasSrc) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Provide either 'src' or 'shape', not both",
+            path: ["src"],
+        });
+    }
+    if (hasSrc) {
+        const disallowedProps = ["shape", "fill", "stroke", "shadow", "transform", "width", "height"];
+        for (const prop of disallowedProps) {
+            if (data[prop] !== undefined) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `'${prop}' is not allowed when using 'src'. Only 'type' and 'src' are allowed in import mode`,
+                    path: [prop],
+                });
+            }
+        }
+    }
+});
 export const svgAssetSchema = svgassetSvgAssetSchema;
 /**
  * Configure the id and optional merge fields to render a template by id.