transloadit 4.14.0 → 5.0.0

package/dist/alphalib/types/robots/google-import.d.ts

@@ -1,15 +1,16 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinition, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod';
 export declare const meta: RobotMetaInput;
 export declare const robotGoogleImportInstructionsSchema: 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">]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
 } & {
     force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
-    ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("import" | "meta" | "execute")[]>>;
+    ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("meta" | "import" | "execute")[]>>;
     import_on_errors: z.ZodDefault<z.ZodArray<z.ZodEnum<["meta"]>, "many">>;
 } & {
     credentials: z.ZodOptional<z.ZodString>;
@@ -21,42 +22,46 @@ export declare const robotGoogleImportInstructionsSchema: z.ZodObject<{
     files_per_page: z.ZodDefault<z.ZodNumber>;
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
+    user_meta: Record<string, unknown>;
     robot: "/google/import";
+    recursive: boolean;
     result: boolean;
     force_accept: boolean;
     ignore_errors: string[];
     force_name: string | string[] | null;
     import_on_errors: "meta"[];
-    recursive: boolean;
     next_page_token: string;
     files_per_page: number;
+    queue?: "batch" | undefined;
     interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    queue?: "batch" | undefined;
     credentials?: string | undefined;
 }, {
     path: string | string[];
     robot: "/google/import";
+    user_meta?: Record<string, unknown> | undefined;
+    queue?: "batch" | undefined;
+    recursive?: boolean | undefined;
     interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | undefined;
-    queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
-    ignore_errors?: boolean | ("import" | "meta" | "execute")[] | undefined;
+    ignore_errors?: boolean | ("meta" | "import" | "execute")[] | undefined;
     force_name?: string | string[] | null | undefined;
     import_on_errors?: "meta"[] | undefined;
     credentials?: string | undefined;
-    recursive?: boolean | undefined;
     next_page_token?: string | undefined;
     files_per_page?: number | undefined;
 }>;
+export declare const robotDefinition: RobotDefinition<typeof robotGoogleImportInstructionsSchema.shape>;
 export declare const robotGoogleImportInstructionsWithHiddenFieldsSchema: 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">]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
     force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
-    ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("import" | "meta" | "execute")[]>>;
+    ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("meta" | "import" | "execute")[]>>;
     import_on_errors: z.ZodDefault<z.ZodArray<z.ZodEnum<["meta"]>, "many">>;
     credentials: z.ZodOptional<z.ZodString>;
     robot: z.ZodLiteral<"/google/import">;
@@ -68,45 +73,45 @@ export declare const robotGoogleImportInstructionsWithHiddenFieldsSchema: z.ZodO
     result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
+    user_meta: Record<string, unknown>;
     robot: "/google/import";
+    recursive: boolean;
     force_accept: boolean;
     ignore_errors: string[];
     force_name: string | string[] | null;
     import_on_errors: "meta"[];
-    recursive: boolean;
     next_page_token: string;
     files_per_page: number;
+    queue?: "batch" | undefined;
     interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | "debug" | undefined;
-    queue?: "batch" | undefined;
     credentials?: string | undefined;
 }, {
     path: string | string[];
     robot: "/google/import";
+    user_meta?: Record<string, unknown> | undefined;
+    queue?: "batch" | undefined;
+    recursive?: boolean | undefined;
     interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | "debug" | undefined;
-    queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
-    ignore_errors?: boolean | ("import" | "meta" | "execute")[] | undefined;
+    ignore_errors?: boolean | ("meta" | "import" | "execute")[] | undefined;
     force_name?: string | string[] | null | undefined;
     import_on_errors?: "meta"[] | undefined;
     credentials?: string | undefined;
-    recursive?: boolean | undefined;
     next_page_token?: string | undefined;
     files_per_page?: number | undefined;
-}>;
-export type RobotGoogleImportInstructions = z.infer<typeof robotGoogleImportInstructionsSchema>;
-export type RobotGoogleImportInstructionsWithHiddenFields = z.infer<typeof robotGoogleImportInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotGoogleImportInstructionsSchema: z.ZodObject<{
+}>, interpolatableRobotGoogleImportInstructionsSchema: 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">]>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("import" | "meta" | "execute")[]>]>>;
+    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("meta" | "import" | "execute")[]>]>>;
     import_on_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<["meta"]>]>, "many">]>>;
     credentials: z.ZodOptional<z.ZodString>;
     robot: z.ZodLiteral<"/google/import">;
@@ -116,44 +121,44 @@ export declare const interpolatableRobotGoogleImportInstructionsSchema: z.ZodObj
     files_per_page: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
+    user_meta: Record<string, unknown>;
     robot: "/google/import";
+    recursive: string | boolean;
     result: string | boolean;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     force_name: string | string[] | null;
     import_on_errors: string | string[];
-    recursive: string | boolean;
     next_page_token: string;
     files_per_page: string | number;
+    queue?: string | undefined;
     interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    queue?: string | undefined;
     credentials?: string | undefined;
 }, {
     path: string | string[];
     robot: "/google/import";
+    user_meta?: Record<string, unknown> | undefined;
+    queue?: string | undefined;
+    recursive?: string | boolean | undefined;
     interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
-    queue?: string | undefined;
     force_accept?: string | boolean | undefined;
-    ignore_errors?: string | boolean | ("import" | "meta" | "execute")[] | undefined;
+    ignore_errors?: string | boolean | ("meta" | "import" | "execute")[] | undefined;
     force_name?: string | string[] | null | undefined;
     import_on_errors?: string | string[] | undefined;
     credentials?: string | undefined;
-    recursive?: string | boolean | undefined;
     next_page_token?: string | undefined;
     files_per_page?: string | number | undefined;
-}>;
-export type InterpolatableRobotGoogleImportInstructions = InterpolatableRobotGoogleImportInstructionsInput;
-export type InterpolatableRobotGoogleImportInstructionsInput = z.input<typeof interpolatableRobotGoogleImportInstructionsSchema>;
-export declare const interpolatableRobotGoogleImportInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+}>, interpolatableRobotGoogleImportInstructionsWithHiddenFieldsSchema: 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">]>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("import" | "meta" | "execute")[]>]>>;
+    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("meta" | "import" | "execute")[]>]>>;
     import_on_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<["meta"]>]>, "many">]>>;
     credentials: z.ZodOptional<z.ZodString>;
     robot: z.ZodLiteral<"/google/import">;
@@ -164,35 +169,43 @@ export declare const interpolatableRobotGoogleImportInstructionsWithHiddenFields
     result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
+    user_meta: Record<string, unknown>;
     robot: "/google/import";
+    recursive: string | boolean;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     force_name: string | string[] | null;
     import_on_errors: string | string[];
-    recursive: string | boolean;
     next_page_token: string;
     files_per_page: string | number;
+    queue?: string | undefined;
     interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
-    queue?: string | undefined;
     credentials?: string | undefined;
 }, {
     path: string | string[];
     robot: "/google/import";
+    user_meta?: Record<string, unknown> | undefined;
+    queue?: string | undefined;
+    recursive?: string | boolean | undefined;
     interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
-    queue?: string | undefined;
     force_accept?: string | boolean | undefined;
-    ignore_errors?: string | boolean | ("import" | "meta" | "execute")[] | undefined;
+    ignore_errors?: string | boolean | ("meta" | "import" | "execute")[] | undefined;
     force_name?: string | string[] | null | undefined;
     import_on_errors?: string | string[] | undefined;
     credentials?: string | undefined;
-    recursive?: string | boolean | undefined;
     next_page_token?: string | undefined;
     files_per_page?: string | number | undefined;
 }>;
-export type InterpolatableRobotGoogleImportInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotGoogleImportInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotGoogleImportInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotGoogleImportInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotGoogleImportInstructions = Instructions['output'];
+export type RobotGoogleImportInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotGoogleImportInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotGoogleImportInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotGoogleImportInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotGoogleImportInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=google-import.d.ts.map

package/dist/alphalib/types/robots/google-import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"google-import.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/google-import.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAavB,eAAO,MAAM,IAAI,EAAE,cAqClB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BrC,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":"google-import.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/google-import.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAevB,eAAO,MAAM,IAAI,EAAE,cAWlB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BrC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,mCAAmC,CAAC,KAAK,CACtC,CAAA;AAExD,eAAO,MACa,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACrD,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACjC,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAChF,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,6BAA6B,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AAClE,MAAM,MAAM,6CAA6C,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AACxF,MAAM,MAAM,2CAA2C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC7F,MAAM,MAAM,gDAAgD,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAClG,MAAM,MAAM,2DAA2D,GACrE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,gEAAgE,GAC1E,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

package/dist/alphalib/types/robots/google-import.js

@@ -1,41 +1,15 @@
 import { z } from 'zod';
-import { files_per_page, googleBase, interpolateRobot, next_page_token, path, recursive, robotBase, robotImport, } from "./_instructions-primitives.js";
+import { createStorageImportExample, defineRobot, googleBase, next_page_token, path, recursive, recursiveImportPageSize, robotBase, robotImport, robotImportMeta, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 10,
-    discount_factor: 0.1,
-    discount_pct: 90,
-    example_code: {
-        steps: {
-            imported: {
-                robot: '/google/import',
-                credentials: 'YOUR_GOOGLE_CREDENTIALS',
-                path: 'path/to/files/',
-                recursive: true,
-            },
-        },
-    },
+    ...robotImportMeta,
+    example_code: createStorageImportExample('/google/import', 'YOUR_GOOGLE_CREDENTIALS'),
     example_code_description: 'Import files from the `path/to/files` directory and its subdirectories:',
     has_small_icon: true,
-    minimum_charge: 0,
-    output_factor: 1,
-    override_lvl1: 'File Importing',
-    purpose_sentence: 'imports whole directories of files from Google Storage',
-    purpose_verb: 'import',
-    purpose_word: 'Google Storage',
-    purpose_words: 'Import files from Google Storage',
-    service_slug: 'file-importing',
-    slot_count: 20,
-    title: 'Import files from Google Storage',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'file',
+    purpose_sentence: 'imports whole directories of files from Google Cloud Storage',
+    purpose_word: 'Google Cloud Storage',
+    purpose_words: 'Import files from Google Cloud Storage',
+    title: 'Import files from Google Cloud Storage',
     name: 'GoogleImportRobot',
-    priceFactor: 6.6666,
-    queueSlotCount: 20,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: false,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
-    stage: 'ga',
 };
 export const robotGoogleImportInstructionsSchema = robotBase
     .merge(robotImport)
@@ -61,16 +35,9 @@ Please use the pagination parameters \`start_file_name\` and \`files_per_page\`
     next_page_token: next_page_token.describe(`
 A string token used for pagination. The returned files of one paginated call have the next page token inside of their meta data, which needs to be used for the subsequent paging call.
 `),
-    files_per_page: files_per_page.describe(`
-The pagination page size. This only works when recursive is \`true\` for now, in order to not break backwards compatibility in non-recursive imports.
-`),
+    files_per_page: recursiveImportPageSize,
 })
     .strict();
-export const robotGoogleImportInstructionsWithHiddenFieldsSchema = robotGoogleImportInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotGoogleImportInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotGoogleImportInstructionsSchema = interpolateRobot(robotGoogleImportInstructionsSchema);
-export const interpolatableRobotGoogleImportInstructionsWithHiddenFieldsSchema = interpolateRobot(robotGoogleImportInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotGoogleImportInstructionsSchema);
+export const { withHiddenFields: robotGoogleImportInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotGoogleImportInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotGoogleImportInstructionsWithHiddenFieldsSchema, } = robotDefinition;
 //# sourceMappingURL=google-import.js.map

package/dist/alphalib/types/robots/google-import.js.map

@@ -1 +1 @@
-{"version":3,"file":"google-import.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/google-import.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EACL,cAAc,EACd,UAAU,EACV,gBAAgB,EAChB,eAAe,EACf,IAAI,EACJ,SAAS,EACT,SAAS,EACT,WAAW,GACZ,MAAM,+BAA+B,CAAA;AAEtC,MAAM,CAAC,MAAM,IAAI,GAAmB;IAClC,UAAU,EAAE,EAAE;IACd,eAAe,EAAE,GAAG;IACpB,YAAY,EAAE,EAAE;IAChB,YAAY,EAAE;QACZ,KAAK,EAAE;YACL,QAAQ,EAAE;gBACR,KAAK,EAAE,gBAAgB;gBACvB,WAAW,EAAE,yBAAyB;gBACtC,IAAI,EAAE,gBAAgB;gBACtB,SAAS,EAAE,IAAI;aAChB;SACF;KACF;IACD,wBAAwB,EACtB,yEAAyE;IAC3E,cAAc,EAAE,IAAI;IACpB,cAAc,EAAE,CAAC;IACjB,aAAa,EAAE,CAAC;IAChB,aAAa,EAAE,gBAAgB;IAC/B,gBAAgB,EAAE,wDAAwD;IAC1E,YAAY,EAAE,QAAQ;IACtB,YAAY,EAAE,gBAAgB;IAC9B,aAAa,EAAE,kCAAkC;IACjD,YAAY,EAAE,gBAAgB;IAC9B,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,kCAAkC;IACzC,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,MAAM;IACzB,IAAI,EAAE,mBAAmB;IACzB,WAAW,EAAE,MAAM;IACnB,cAAc,EAAE,EAAE;IAClB,wBAAwB,EAAE,IAAI;IAC9B,mBAAmB,EAAE,KAAK;IAC1B,UAAU,EAAE,KAAK;IACjB,iDAAiD,EAAE,IAAI;IACvD,KAAK,EAAE,IAAI;CACZ,CAAA;AAED,MAAM,CAAC,MAAM,mCAAmC,GAAG,SAAS;KACzD,KAAK,CAAC,WAAW,CAAC;KAClB,KAAK,CAAC,UAAU,CAAC;KACjB,MAAM,CAAC;IACN,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,gBAAgB,CAAC;IAClC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC;;;;;;;;;;CAUvB,CAAC;IACE,SAAS,EAAE,SAAS,CAAC,QAAQ,CAAC;;;;CAIjC,CAAC;IACE,eAAe,EAAE,eAAe,CAAC,QAAQ,CAAC;;CAE7C,CAAC;IACE,cAAc,EAAE,cAAc,CAAC,QAAQ,CAAC;;CAE3C,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,mDAAmD,GAC9D,mCAAmC,CAAC,MAAM,CAAC;IACzC,MAAM,EAAE,CAAC;SACN,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,mCAAmC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;SAC7E,QAAQ,EAAE;CACd,CAAC,CAAA;AAOJ,MAAM,CAAC,MAAM,iDAAiD,GAAG,gBAAgB,CAC/E,mCAAmC,CACpC,CAAA;AAQD,MAAM,CAAC,MAAM,iEAAiE,GAAG,gBAAgB,CAC/F,mDAAmD,CACpD,CAAA"}
+{"version":3,"file":"google-import.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/google-import.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EACL,0BAA0B,EAC1B,WAAW,EACX,UAAU,EACV,eAAe,EACf,IAAI,EACJ,SAAS,EACT,uBAAuB,EACvB,SAAS,EACT,WAAW,EACX,eAAe,GAChB,MAAM,+BAA+B,CAAA;AAEtC,MAAM,CAAC,MAAM,IAAI,GAAmB;IAClC,GAAG,eAAe;IAClB,YAAY,EAAE,0BAA0B,CAAC,gBAAgB,EAAE,yBAAyB,CAAC;IACrF,wBAAwB,EACtB,yEAAyE;IAC3E,cAAc,EAAE,IAAI;IACpB,gBAAgB,EAAE,8DAA8D;IAChF,YAAY,EAAE,sBAAsB;IACpC,aAAa,EAAE,wCAAwC;IACvD,KAAK,EAAE,wCAAwC;IAC/C,IAAI,EAAE,mBAAmB;CAC1B,CAAA;AAED,MAAM,CAAC,MAAM,mCAAmC,GAAG,SAAS;KACzD,KAAK,CAAC,WAAW,CAAC;KAClB,KAAK,CAAC,UAAU,CAAC;KACjB,MAAM,CAAC;IACN,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,gBAAgB,CAAC;IAClC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC;;;;;;;;;;CAUvB,CAAC;IACE,SAAS,EAAE,SAAS,CAAC,QAAQ,CAAC;;;;CAIjC,CAAC;IACE,eAAe,EAAE,eAAe,CAAC,QAAQ,CAAC;;CAE7C,CAAC;IACE,cAAc,EAAE,uBAAuB;CACxC,CAAC;KACD,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,eAAe,GAC1B,WAAW,CAAC,IAAI,EAAE,mCAAmC,CAAC,CAAA;AAExD,MAAM,CAAC,MAAM,EACX,gBAAgB,EAAE,mDAAmD,EACrE,cAAc,EAAE,iDAAiD,EACjE,8BAA8B,EAAE,iEAAiE,GAClG,GAAG,eAAe,CAAA"}