@transloadit/node 4.10.2 → 4.10.3

package/dist/alphalib/types/robots/youtube-store.d.ts

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotYoutubeStoreInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
@@ -75,6 +76,7 @@ export declare const robotYoutubeStoreInstructionsSchema: z.ZodObject<{
     category: "science & technology" | "autos & vehicles" | "comedy" | "education" | "entertainment" | "film & animation" | "gaming" | "howto & style" | "music" | "news & politics" | "people & blogs" | "pets & animals" | "sports" | "travel & events";
     keywords: string;
     visibility: "public" | "private" | "unlisted";
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -98,6 +100,7 @@ export declare const robotYoutubeStoreInstructionsSchema: z.ZodObject<{
     credentials: string;
     keywords: string;
     visibility: "public" | "private" | "unlisted";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -120,6 +123,7 @@ export declare const robotYoutubeStoreInstructionsSchema: z.ZodObject<{
     category?: unknown;
 }>;
 export declare const robotYoutubeStoreInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
@@ -191,6 +195,7 @@ export declare const robotYoutubeStoreInstructionsWithHiddenFieldsSchema: z.ZodO
     category: "science & technology" | "autos & vehicles" | "comedy" | "education" | "entertainment" | "film & animation" | "gaming" | "howto & style" | "music" | "news & politics" | "people & blogs" | "pets & animals" | "sports" | "travel & events";
     keywords: string;
     visibility: "public" | "private" | "unlisted";
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -215,6 +220,7 @@ export declare const robotYoutubeStoreInstructionsWithHiddenFieldsSchema: z.ZodO
     credentials: string;
     keywords: string;
     visibility: "public" | "private" | "unlisted";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -239,6 +245,7 @@ export declare const robotYoutubeStoreInstructionsWithHiddenFieldsSchema: z.ZodO
 export type RobotYoutubeStoreInstructions = z.infer<typeof robotYoutubeStoreInstructionsSchema>;
 export type RobotYoutubeStoreInstructionsWithHiddenFields = z.infer<typeof robotYoutubeStoreInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotYoutubeStoreInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
@@ -310,6 +317,7 @@ export declare const interpolatableRobotYoutubeStoreInstructionsSchema: z.ZodObj
     category: string;
     keywords: string;
     visibility: string;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -333,6 +341,7 @@ export declare const interpolatableRobotYoutubeStoreInstructionsSchema: z.ZodObj
     credentials: string;
     keywords: string;
     visibility: string;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -357,6 +366,7 @@ export declare const interpolatableRobotYoutubeStoreInstructionsSchema: z.ZodObj
 export type InterpolatableRobotYoutubeStoreInstructions = InterpolatableRobotYoutubeStoreInstructionsInput;
 export type InterpolatableRobotYoutubeStoreInstructionsInput = z.input<typeof interpolatableRobotYoutubeStoreInstructionsSchema>;
 export declare const interpolatableRobotYoutubeStoreInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
@@ -427,6 +437,7 @@ export declare const interpolatableRobotYoutubeStoreInstructionsWithHiddenFields
     category: string;
     keywords: string;
     visibility: string;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -451,6 +462,7 @@ export declare const interpolatableRobotYoutubeStoreInstructionsWithHiddenFields
     credentials: string;
     keywords: string;
     visibility: string;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;

package/dist/alphalib/types/robots/youtube-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"youtube-store.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/youtube-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAGnE,eAAO,MAAM,IAAI,EAAE,cAwClB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwErC,CAAA;AAEX,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK5D,CAAA;AAEJ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CACjE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7D,CAAA;AACD,MAAM,MAAM,2CAA2C,GACrD,gDAAgD,CAAA;AAElD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7E,CAAA;AACD,MAAM,MAAM,2DAA2D,GAAG,CAAC,CAAC,KAAK,CAC/E,OAAO,iEAAiE,CACzE,CAAA;AACD,MAAM,MAAM,gEAAgE,GAAG,CAAC,CAAC,KAAK,CACpF,OAAO,iEAAiE,CACzE,CAAA"}
+{"version":3,"file":"youtube-store.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/youtube-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAGnE,eAAO,MAAM,IAAI,EAAE,cAwClB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwErC,CAAA;AAEX,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK5D,CAAA;AAEJ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CACjE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7D,CAAA;AACD,MAAM,MAAM,2CAA2C,GACrD,gDAAgD,CAAA;AAElD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7E,CAAA;AACD,MAAM,MAAM,2DAA2D,GAAG,CAAC,CAAC,KAAK,CAC/E,OAAO,iEAAiE,CACzE,CAAA;AACD,MAAM,MAAM,gEAAgE,GAAG,CAAC,CAAC,KAAK,CACpF,OAAO,iEAAiE,CACzE,CAAA"}

package/dist/alphalib/types/template.js

@@ -93,12 +93,12 @@ The \`referer\` property is a regular expression to match against the HTTP refer
 Uploads without a referer will always pass (as they are turned off for some browsers) making this useful in just a handful of use cases. For details about regular expressions, see [Mozilla's RegExp documentation](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/RegExp).
 
 The \`max_size\` property can be used to set a maximum size that an upload can have in bytes, such as \`1048576\` (1 MB). Specify this to prevent users from uploading excessively large files.
-
-This can be set as part of the Assembly request or as part of the Template.
-
 The file size is checked as soon as the upload is started and if it exceeds the maximum size, the entire upload process is canceled and the Assembly will error out, even if it contains files that do not exceed the \`max_size\` limitation.
-
 If you want to just ignore the files that exceed a certain size, but process all others, then please use [🤖/file/filter](https://transloadit.com/docs/robots/file-filter/).
+
+The \`max_number_of_files\` property can be used to set a maximum number of files that an upload can have, such as \`100\`. Specify this to prevent users from uploading excessively many files, both via file uploads and via import Robots.
+
+These properties can be set as part of the Assembly request or as part of the Template.
 `);
 const assemblyInstructionsSharedShape = {
     allow_steps_override: z

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@transloadit/node",
-  "version": "4.10.2",
+  "version": "4.10.3",
   "description": "Node.js SDK for Transloadit",
   "homepage": "https://github.com/transloadit/node-sdk/tree/main/packages/node",
   "bugs": {

package/src/alphalib/errors.ts

@@ -0,0 +1,34 @@
+import { getRecordProperty, isRecord } from './object.ts'
+
+export function normalizeError(err: unknown): Error {
+  if (err instanceof Error) {
+    return err
+  }
+
+  return new Error(`Was thrown a non-error: ${String(err)}`, { cause: err })
+}
+
+export function getErrorMessage(err: unknown): string {
+  return err instanceof Error ? err.message : String(err)
+}
+
+export function getErrorCode(err: unknown): unknown {
+  return isRecord(err) && 'code' in err ? err.code : undefined
+}
+
+export function getErrorCodeOrValue(err: unknown): unknown {
+  return isRecord(err) && 'code' in err ? err.code : err
+}
+
+export function getNodeErrorCode(err: unknown): string | undefined {
+  const code = getErrorCode(err)
+  return typeof code === 'string' ? code : undefined
+}
+
+export function isErrnoException(err: unknown): err is NodeJS.ErrnoException {
+  return isRecord(err) && 'code' in err
+}
+
+export function getErrorProperty(err: unknown, property: PropertyKey): unknown {
+  return getRecordProperty(err, property)
+}

package/src/alphalib/object.ts

@@ -1,10 +1,50 @@
 import type { Entries } from 'type-fest'
 
+export type UnknownRecord = Record<PropertyKey, unknown>
+
 /**
  * See https://github.com/microsoft/TypeScript/pull/12253#issuecomment-263132208 for
  * some background on why this exists and why this isn't in TypeScript by default.
  */
 
+export function isRecord(value: unknown): value is UnknownRecord {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+export function isObjectLike(value: unknown): value is UnknownRecord {
+  return (typeof value === 'object' && value !== null) || typeof value === 'function'
+}
+
+export function isPlainRecord(value: unknown): value is UnknownRecord {
+  return isRecord(value)
+}
+
+export function isStringRecord(value: unknown): value is Record<string, string> {
+  if (!isRecord(value)) {
+    return false
+  }
+
+  return Object.values(value).every((entry) => typeof entry === 'string')
+}
+
+export function getRecordProperty(value: unknown, property: PropertyKey): unknown {
+  if (!isRecord(value)) {
+    return undefined
+  }
+
+  return value[property]
+}
+
+export function getStringProperty(value: unknown, property: PropertyKey): string | undefined {
+  const propertyValue = getRecordProperty(value, property)
+  return typeof propertyValue === 'string' ? propertyValue : undefined
+}
+
+export function getNumberProperty(value: unknown, property: PropertyKey): number | undefined {
+  const propertyValue = getRecordProperty(value, property)
+  return typeof propertyValue === 'number' ? propertyValue : undefined
+}
+
 /**
  * Returns properly typed entries of an object
  */

package/src/alphalib/types/assemblyStatus.ts

@@ -20,6 +20,7 @@ export const assemblyStatusOkCodeSchema = z.enum([
 
 export const assemblyStatusErrCodeSchema = z.enum([
   'ADMIN_PERMISSIONS_REQUIRED',
+  'AI_CHAT_VALIDATION',
   'ASSEMBLY_ACCOUNT_MISMATCH',
   'ASSEMBLY_CANNOT_BE_REPLAYED',
   'ASSEMBLY_COULD_NOT_BE_CREATED',
@@ -37,92 +38,173 @@ export const assemblyStatusErrCodeSchema = z.enum([
   'ASSEMBLY_JOB_ENQUEUE_ERROR',
   'ASSEMBLY_LIST_ERROR',
   'ASSEMBLY_MEMORY_LIMIT_EXCEEDED',
-  'ASSEMBLY_NO_CHARGEABLE_STEP',
-  'ASSEMBLY_NO_STEPS',
+  'ASSEMBLY_NOTIFICATIONS_LIST_ERROR',
+  'ASSEMBLY_NOTIFICATION_LIST_ERROR',
+  'ASSEMBLY_NOTIFICATION_NOT_PERSISTED',
+  'ASSEMBLY_NOTIFICATION_NOT_REPLAYED',
   'ASSEMBLY_NOT_CAPABLE',
   'ASSEMBLY_NOT_FINISHED',
   'ASSEMBLY_NOT_FOUND',
   'ASSEMBLY_NOT_REPLAYED',
-  'ASSEMBLY_NOTIFICATION_LIST_ERROR',
-  'ASSEMBLY_NOTIFICATION_NOT_PERSISTED',
-  'ASSEMBLY_NOTIFICATION_NOT_REPLAYED',
-  'ASSEMBLY_NOTIFICATIONS_LIST_ERROR',
+  'ASSEMBLY_NO_CHARGEABLE_STEP',
   'ASSEMBLY_NO_NOTIFY_URL',
+  'ASSEMBLY_NO_STEPS',
   'ASSEMBLY_PLAN_FILE_SIZE_LIMIT_EXCEEDED',
   'ASSEMBLY_ROBOT_MISSING',
   'ASSEMBLY_SATURATED',
   'ASSEMBLY_STATS_ERROR',
   'ASSEMBLY_STATS_INVALID_TIME',
   'ASSEMBLY_STATS_MISSING_REGION',
-  'PRIORITY_JOB_SLOT_STATS_ERROR',
-  'PRIORITY_JOB_SLOT_STATS_INVALID_AGGREGATION',
-  'PRIORITY_JOB_SLOT_STATS_INVALID_TIME',
-  'PRIORITY_JOB_SLOT_STATS_MISSING_REGION',
   'ASSEMBLY_STATUS_FETCHING_RATE_LIMIT_REACHED',
   'ASSEMBLY_STATUS_NOT_FOUND',
   'ASSEMBLY_STATUS_PARSE_ERROR',
+  'ASSEMBLY_STEP_INVALID',
   'ASSEMBLY_STEP_INVALID_ROBOT',
   'ASSEMBLY_STEP_INVALID_USE',
-  'ASSEMBLY_STEP_INVALID',
   'ASSEMBLY_STEP_NO_ROBOT',
   'ASSEMBLY_STEP_UNKNOWN_ROBOT',
   'ASSEMBLY_STEP_UNKNOWN_USE',
-  'AI_CHAT_VALIDATION',
   'ASSEMBLY_URL_TRANSFORM_MISSING',
+  'AUDIO_ARTWORK_VALIDATION',
+  'AUDIO_CONCAT_INVALID_INPUT',
+  'AUDIO_CONCAT_VALIDATION',
+  'AUDIO_ENCODE_VALIDATION',
+  'AUDIO_LOOP_VALIDATION',
+  'AUDIO_MERGE_VALIDATION',
+  'AUDIO_SPLIT_NO_OUTPUT',
+  'AUDIO_SPLIT_VALIDATION',
+  'AUDIO_WAVEFORM_VALIDATION',
   'AUTH_EXPIRED',
-  'AUTH_KEY_SCOPES_NOT_FOUND',
   'AUTH_KEYS_NOT_FOUND',
+  'AUTH_KEY_SCOPES_NOT_FOUND',
   'AUTH_SECRET_NOT_RETRIEVED',
-  'AUDIO_WAVEFORM_VALIDATION',
+  'AZURE_IMPORT_ACCESS_DENIED',
+  'AZURE_IMPORT_FAILURE',
+  'AZURE_IMPORT_NOT_FOUND',
+  'AZURE_IMPORT_VALIDATION',
   'AZURE_STORE_ACCESS_DENIED',
-  'BEARER_TOKEN_AUTH_KEY_MISMATCH',
-  'BEARER_TOKEN_EXPIRED',
-  'BEARER_TOKEN_INVALID',
+  'AZURE_STORE_VALIDATION',
   'BACKBLAZE_IMPORT_ACCESS_DENIED',
+  'BACKBLAZE_IMPORT_FAILURE',
   'BACKBLAZE_IMPORT_NOT_FOUND',
+  'BACKBLAZE_IMPORT_VALIDATION',
   'BACKBLAZE_STORE_ACCESS_DENIED',
   'BACKBLAZE_STORE_FAILURE',
+  'BACKBLAZE_STORE_VALIDATION',
   'BAD_PRICING',
+  'BEARER_TOKEN_AUTH_KEY_MISMATCH',
+  'BEARER_TOKEN_EXPIRED',
+  'BEARER_TOKEN_INVALID',
   'BILL_LIMIT_EXCEEDED',
+  'BOX_IMPORT_ACCESS_DENIED',
+  'BOX_IMPORT_FAILURE',
+  'BOX_IMPORT_NOT_FOUND',
+  'BOX_IMPORT_VALIDATION',
+  'BOX_STORE_COULD_NOT_PARSE_URL',
+  'BOX_STORE_VALIDATION',
   'CANNOT_ACCEPT_NEW_ASSEMBLIES',
   'CANNOT_FETCH_ACTIVE_ASSEMBLIES',
   'CDN_REQUIRED',
   'CLOUDFILES_IMPORT_ACCESS_DENIED',
+  'CLOUDFILES_IMPORT_FAILURE',
   'CLOUDFILES_IMPORT_NOT_FOUND',
+  'CLOUDFILES_IMPORT_VALIDATION',
   'CLOUDFILES_STORE_ACCESS_DENIED',
   'CLOUDFILES_STORE_ERROR',
+  'CLOUDFILES_STORE_VALIDATION',
+  'CLOUDFLARE_IMPORT_ACCESS_DENIED',
+  'CLOUDFLARE_IMPORT_FAILURE',
+  'CLOUDFLARE_IMPORT_NOT_FOUND',
   'CLOUDFLARE_IMPORT_VALIDATION',
+  'CLOUDFLARE_STORE_URL_VERIFICATION_FAILURE',
+  'CLOUDFLARE_STORE_VALIDATION',
+  'CLOUD_AI_IMAGE_VALIDATION',
+  'DIGITALOCEAN_IMPORT_ACCESS_DENIED',
+  'DIGITALOCEAN_IMPORT_FAILURE',
+  'DIGITALOCEAN_IMPORT_NOT_FOUND',
+  'DIGITALOCEAN_IMPORT_VALIDATION',
   'DIGITALOCEAN_STORE_ACCESS_DENIED',
-  'DO_NOT_REUSE_ASSEMBLY_IDS',
+  'DIGITALOCEAN_STORE_VALIDATION',
+  'DOCUMENT_AUTOROTATE_VALIDATION',
   'DOCUMENT_CONVERT_UNSUPPORTED_CONVERSION',
+  'DOCUMENT_CONVERT_VALIDATION',
+  'DOCUMENT_MERGE_UNSUPPORTED_CONVERSION',
+  'DOCUMENT_MERGE_VALIDATION',
+  'DOCUMENT_OCR_VALIDATION',
   'DOCUMENT_OPTIMIZE_UNSUPPORTED_INPUT',
   'DOCUMENT_OPTIMIZE_VALIDATION',
   'DOCUMENT_SPLIT_VALIDATION',
+  'DOCUMENT_THUMBS_INVALID_INPUT',
   'DOCUMENT_THUMBS_VALIDATION',
+  'DO_NOT_REUSE_ASSEMBLY_IDS',
+  'DROPBOX_IMPORT_ACCESS_DENIED',
+  'DROPBOX_IMPORT_FAILURE',
+  'DROPBOX_IMPORT_NOT_FOUND',
+  'DROPBOX_IMPORT_VALIDATION',
+  'DROPBOX_STORE_COULD_NOT_PARSE_URL',
+  'DROPBOX_STORE_VALIDATION',
+  'FILE_COMPRESS_INVALID_INPUT',
+  'FILE_COMPRESS_VALIDATION',
+  'FILE_DECOMPRESS_INVALID_INPUT',
+  'FILE_DECOMPRESS_PASSWORD_INCORRECT',
+  'FILE_DECOMPRESS_PASSWORD_REQUIRED',
+  'FILE_DECOMPRESS_VALIDATION',
   'FILE_DOWNLOAD_ERROR',
   'FILE_FILTER_DECLINED_FILE',
   'FILE_FILTER_INVALID_OPERATOR',
   'FILE_FILTER_VALIDATION',
+  'FILE_HASH_VALIDATION',
   'FILE_META_DATA_ERROR',
   'FILE_PREVIEW_VALIDATION',
   'FILE_READ_VALIDATION_ERROR',
   'FILE_SERVE_NO_RESULT',
+  'FILE_SERVE_VALIDATION',
   'FILE_VERIFY_INVALID_FILE',
+  'FILE_VERIFY_VALIDATION',
   'FILE_VIRUSSCAN_DECLINED_FILE',
+  'FILE_VIRUSSCAN_INVALID_INPUT',
+  'FILE_VIRUSSCAN_VALIDATION',
+  'FILE_WATERMARK_VALIDATION',
+  'FTP_IMPORT_ACCESS_DENIED',
+  'FTP_IMPORT_FAILURE',
+  'FTP_IMPORT_NOT_FOUND',
+  'FTP_IMPORT_VALIDATION',
+  'FTP_STORE_VALIDATION',
   'GET_ACCOUNT_DB_ERROR',
   'GET_ACCOUNT_UNKNOWN_AUTH_KEY',
+  'GOOGLE_IMPORT_ACCESS_DENIED',
+  'GOOGLE_IMPORT_FAILURE',
+  'GOOGLE_IMPORT_NOT_FOUND',
   'GOOGLE_IMPORT_VALIDATION',
+  'GOOGLE_STORE_INVALID_INPUT',
   'GOOGLE_STORE_VALIDATION',
   'HTML_CONVERT_VALIDATION',
   'HTTP_IMPORT_ACCESS_DENIED',
   'HTTP_IMPORT_FAILURE',
   'HTTP_IMPORT_NOT_FOUND',
   'HTTP_IMPORT_VALIDATION',
+  'IMAGE_BGREMOVE_VALIDATION',
+  'IMAGE_COPYRIGHT_DETECT_DECLINED_FILE',
+  'IMAGE_COPYRIGHT_DETECT_VALIDATION',
   'IMAGE_DESCRIBE_VALIDATION',
   'IMAGE_ENHANCE_NO_INPUT_FILE',
   'IMAGE_ENHANCE_VALIDATION',
+  'IMAGE_FACEDETECT_VALIDATION',
+  'IMAGE_GENERATE_VALIDATION',
+  'IMAGE_MERGE_FAILURE',
+  'IMAGE_MERGE_VALIDATION',
+  'IMAGE_OCR_VALIDATION',
+  'IMAGE_OPTIMIZE_VALIDATION',
   'IMAGE_RESIZE_ERROR',
+  'IMAGE_RESIZE_INVALID_BLUR_REGION',
+  'IMAGE_RESIZE_INVALID_TEXT_OBJECT_VALUE',
+  'IMAGE_RESIZE_INVALID_TEXT_VALUE',
+  'IMAGE_RESIZE_INVALID_WATERMARK_OFFSET',
+  'IMAGE_RESIZE_INVALID_WATERMARK_POSITION',
+  'IMAGE_RESIZE_NO_CLUT_FILE',
+  'IMAGE_RESIZE_NO_INPUT_FILE',
   'IMAGE_RESIZE_VALIDATION',
+  'IMAGE_UPSCALE_VALIDATION',
   'IMPORT_FILE_ERROR',
   'INCOMPLETE_PRICING',
   'INSUFFICIENT_AUTH_SCOPE',
@@ -136,15 +218,26 @@ export const assemblyStatusErrCodeSchema = z.enum([
   'INVALID_AUTH_REFERER_PARAMETER',
   'INVALID_FILE_META_DATA',
   'INVALID_FORM_DATA',
-  'INVALID_URL_ENCODING',
   'INVALID_INPUT_ERROR',
   'INVALID_PARAMS_FIELD',
   'INVALID_SIGNATURE',
   'INVALID_STEP_NAME',
   'INVALID_TEMPLATE_FIELD',
   'INVALID_UPLOAD_HANDLE_STEP_NAME',
+  'INVALID_URL_ENCODING',
   'MAX_NUMBER_OF_FILES_EXCEEDED',
   'MAX_SIZE_EXCEEDED',
+  'MEGA_IMPORT_ACCESS_DENIED',
+  'MEGA_IMPORT_FAILURE',
+  'MEGA_IMPORT_NOT_FOUND',
+  'MEGA_IMPORT_VALIDATION',
+  'MEGA_STORE_VALIDATION',
+  'META_WRITE_VALIDATION',
+  'MINIO_IMPORT_ACCESS_DENIED',
+  'MINIO_IMPORT_FAILURE',
+  'MINIO_IMPORT_NOT_FOUND',
+  'MINIO_IMPORT_VALIDATION',
+  'MINIO_STORE_VALIDATION',
   'NO_AUTH_EXPIRES_PARAMETER',
   'NO_AUTH_KEY_PARAMETER',
   'NO_AUTH_PARAMETER',
@@ -160,37 +253,100 @@ export const assemblyStatusErrCodeSchema = z.enum([
   'PLAN_LIMIT_EXCEEDED',
   'POSSIBLY_MALICIOUS_FILE_FOUND',
   'PRIORITY_JOB_SLOTS_NOT_FOUND',
+  'PRIORITY_JOB_SLOT_STATS_ERROR',
+  'PRIORITY_JOB_SLOT_STATS_INVALID_AGGREGATION',
+  'PRIORITY_JOB_SLOT_STATS_INVALID_TIME',
+  'PRIORITY_JOB_SLOT_STATS_MISSING_REGION',
+  'PROGRESS_SIMULATE_VALIDATION',
   'RATE_LIMIT_REACHED',
   'REFERER_MISMATCH',
   'REQUEST_PREMATURE_CLOSED',
   'ROBOT_VALIDATION_BASE_ERROR',
   'S3_ACCESS_DENIED',
   'S3_IMPORT_ACCESS_DENIED',
+  'S3_IMPORT_FAILURE',
+  'S3_IMPORT_NOT_FOUND',
   'S3_IMPORT_VALIDATION',
   'S3_NOT_FOUND',
   'S3_STORE_ACCESS_DENIED',
+  'S3_STORE_FAILURE',
+  'S3_STORE_URL_VERIFICATION_FAILURE',
   'S3_STORE_VALIDATION',
+  'SCRIPT_RUN_VALIDATION',
   'SERVER_403',
   'SERVER_404',
   'SERVER_500',
+  'SFTP_IMPORT_ACCESS_DENIED',
+  'SFTP_IMPORT_FAILURE',
+  'SFTP_IMPORT_NOT_FOUND',
+  'SFTP_IMPORT_VALIDATION',
+  'SFTP_STORE_VALIDATION',
   'SIGNATURE_REUSE_DETECTED',
+  'SLOT_COUNTS_ERROR',
   'SLOT_COUNT_ERROR',
   'SLOT_COUNT_MISSING_PARAMS',
-  'SLOT_COUNTS_ERROR',
+  'SPEECH_TRANSCRIBE_VALIDATION',
+  'SUPABASE_IMPORT_ACCESS_DENIED',
+  'SUPABASE_IMPORT_FAILURE',
+  'SUPABASE_IMPORT_NOT_FOUND',
+  'SUPABASE_IMPORT_VALIDATION',
+  'SUPABASE_STORE_VALIDATION',
+  'SWIFT_IMPORT_ACCESS_DENIED',
+  'SWIFT_IMPORT_FAILURE',
+  'SWIFT_IMPORT_NOT_FOUND',
+  'SWIFT_IMPORT_VALIDATION',
+  'SWIFT_STORE_VALIDATION',
   'TEMPLATE_CREDENTIALS_INJECTION_ERROR',
   'TEMPLATE_DB_ERROR',
   'TEMPLATE_DENIES_STEPS_OVERRIDE',
   'TEMPLATE_INVALID_JSON',
   'TEMPLATE_NOT_FOUND',
+  'TEXT_SPEAK_VALIDATION',
+  'TEXT_TRANSLATE_VALIDATION',
+  'TIGRIS_IMPORT_ACCESS_DENIED',
+  'TIGRIS_IMPORT_FAILURE',
+  'TIGRIS_IMPORT_NOT_FOUND',
+  'TIGRIS_IMPORT_VALIDATION',
+  'TIGRIS_STORE_VALIDATION',
   'TMP_FILE_DOWNLOAD_ERROR',
+  'TOKEN_INVALID_CREDENTIALS',
+  'TUS_STORE_VALIDATION',
   'USER_COMMAND_ERROR',
   'VERIFIED_EMAIL_REQUIRED',
+  'VIDEO_ADAPTIVE_VALIDATION',
+  'VIDEO_ARTWORK_VALIDATION',
   'VIDEO_CONCAT_INVALID_INPUT',
   'VIDEO_CONCAT_NO_OUTPUT',
   'VIDEO_CONCAT_VALIDATION',
+  'VIDEO_ENCODE_INVALID_VIDEO_CODEC',
+  'VIDEO_ENCODE_INVALID_WATERMARK_POSITION',
   'VIDEO_ENCODE_VALIDATION',
+  'VIDEO_GENERATE_VALIDATION',
+  'VIDEO_MERGE_NO_IMAGE_FOUND',
+  'VIDEO_MERGE_VALIDATION',
+  'VIDEO_ONDEMAND_NOT_FOUND',
+  'VIDEO_ONDEMAND_VALIDATION',
+  'VIDEO_SPLIT_NO_OUTPUT',
+  'VIDEO_SPLIT_VALIDATION',
+  'VIDEO_SUBTITLE_VALIDATION',
+  'VIDEO_THUMBS_INVALID_COUNT_VALUE',
+  'VIDEO_THUMBS_INVALID_INPUT',
+  'VIDEO_THUMBS_VALIDATION',
+  'VIMEO_IMPORT_ACCESS_DENIED',
   'VIMEO_IMPORT_FAILURE',
+  'VIMEO_IMPORT_NOT_FOUND',
+  'VIMEO_IMPORT_VALIDATION',
+  'VIMEO_STORE_ACCESS_DENIED',
+  'VIMEO_STORE_PROBLEM_SENDING_FILE',
+  'VIMEO_STORE_VALIDATION',
+  'WASABI_IMPORT_ACCESS_DENIED',
+  'WASABI_IMPORT_FAILURE',
+  'WASABI_IMPORT_NOT_FOUND',
+  'WASABI_IMPORT_VALIDATION',
+  'WASABI_STORE_VALIDATION',
   'WORKER_JOB_ERROR',
+  'YOUTUBE_STORE_PROBLEM_SENDING_FILE',
+  'YOUTUBE_STORE_VALIDATION',
 ])
 
 const assemblyStatusMetaSchema = z
@@ -428,7 +584,7 @@ export const assemblyStatusUploadSchema = z
     type: z.string().nullable(),
     field: z.string().nullable(),
     md5hash: z.string().nullable(),
-    original_id: z.union([z.string(), z.array(z.string())]),
+    original_id: z.union([z.string(), z.array(z.string().nullable())]),
     original_basename: z.string(),
     original_name: z.string(),
     original_path: z.string(),
@@ -463,7 +619,7 @@ export const assemblyStatusResultSchema = z
     basename: z.string().nullable().optional(),
     field: z.string().nullable().optional(),
     md5hash: z.string().nullable().optional(),
-    original_id: z.union([z.string(), z.array(z.string())]).optional(),
+    original_id: z.union([z.string(), z.array(z.string().nullable())]).optional(),
     original_basename: z.string().nullable().optional(),
     original_path: z.string().nullable().optional(),
     original_md5hash: z.string().nullable().optional(),
@@ -913,13 +1069,16 @@ export const assemblyIndexItemSchema = z
     instance: assemblyStatusBaseSchema.shape.instance.unwrap().optional(),
     notify_url: assemblyStatusBaseSchema.shape.notify_url.optional(),
     redirect_url: z.string().nullable().optional(),
-    files: z.string().nullable(), // JSON stringified, specific to list item, CAN BE NULL
+    files: z.string().nullable().optional(), // JSON stringified list metadata; replay rows omit it
     warning_count: z.number().optional(),
     execution_duration: assemblyStatusBaseSchema.shape.execution_duration.optional(),
     execution_start: assemblyStatusBaseSchema.shape.execution_start.optional(),
     region: assemblyStatusBaseSchema.shape.region.optional(),
     num_input_files: assemblyStatusBaseSchema.shape.num_input_files.optional(),
     bytes_usage: assemblyStatusBaseSchema.shape.bytes_usage.optional(),
+    bytes_expected: assemblyStatusBaseSchema.shape.bytes_expected.optional(),
+    bytes_received: assemblyStatusBaseSchema.shape.bytes_received.optional(),
+    upload_duration: assemblyStatusBaseSchema.shape.upload_duration.optional(),
     ok: assemblyStatusOkCodeSchema.nullable().optional(),
     error: assemblyStatusErrCodeSchema.nullable().optional(),
     created: z.string(),

package/src/alphalib/types/robots/_index.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod'
 
-type RobotSchemaOption = z.ZodObject<any>
+type RobotSchemaOption = z.ZodObject<{ robot: z.ZodTypeAny } & z.ZodRawShape>
 type RobotSchemaOptions = [RobotSchemaOption, ...RobotSchemaOption[]]
 import {
   meta as aiChatMeta,