@webiny/project 0.0.0-unstable.61c048f412

package/extensions/ProjectId.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const ProjectId: import("../defineExtension/defineExtension.js").ExtensionComponent<z.ZodObject<{
+    id: z.ZodEffects<z.ZodString, string, string>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>>;

package/extensions/ProjectId.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import { defineExtension } from "../defineExtension/index.js";
+export const ProjectId = defineExtension({
+  type: "Project/ProjectId",
+  tags: {
+    runtimeContext: "project"
+  },
+  description: "An extension for defining the project ID.",
+  paramsSchema: z.object({
+    id: z.string().refine(value => {
+      // Allow only alphanumeric characters, dashes, underscores, no spaces, and forward slashes.
+      return /^[a-zA-Z0-9-_\/]+$/.test(value);
+    }, {
+      message: "Project ID can only contain alphanumeric characters, dashes, underscores, and forward slashes."
+    })
+  })
+});
+
+//# sourceMappingURL=ProjectId.js.map

package/extensions/ProjectId.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["z","defineExtension","ProjectId","type","tags","runtimeContext","description","paramsSchema","object","id","string","refine","value","test","message"],"sources":["ProjectId.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { defineExtension } from \"../defineExtension/index.js\";\n\nexport const ProjectId = defineExtension({\n    type: \"Project/ProjectId\",\n    tags: { runtimeContext: \"project\" },\n    description: \"An extension for defining the project ID.\",\n    paramsSchema: z.object({\n        id: z.string().refine(\n            value => {\n                // Allow only alphanumeric characters, dashes, underscores, no spaces, and forward slashes.\n                return /^[a-zA-Z0-9-_\\/]+$/.test(value);\n            },\n            {\n                message:\n                    \"Project ID can only contain alphanumeric characters, dashes, underscores, and forward slashes.\"\n            }\n        )\n    })\n});\n"],"mappings":"AAAA,SAASA,CAAC,QAAQ,KAAK;AACvB,SAASC,eAAe;AAExB,OAAO,MAAMC,SAAS,GAAGD,eAAe,CAAC;EACrCE,IAAI,EAAE,mBAAmB;EACzBC,IAAI,EAAE;IAAEC,cAAc,EAAE;EAAU,CAAC;EACnCC,WAAW,EAAE,2CAA2C;EACxDC,YAAY,EAAEP,CAAC,CAACQ,MAAM,CAAC;IACnBC,EAAE,EAAET,CAAC,CAACU,MAAM,CAAC,CAAC,CAACC,MAAM,CACjBC,KAAK,IAAI;MACL;MACA,OAAO,oBAAoB,CAACC,IAAI,CAACD,KAAK,CAAC;IAC3C,CAAC,EACD;MACIE,OAAO,EACH;IACR,CACJ;EACJ,CAAC;AACL,CAAC,CAAC","ignoreList":[]}

package/extensions/ProjectImplementation.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const ProjectImplementation: import("../defineExtension/defineExtension.js").ExtensionComponent<z.ZodObject<{
+    src: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    singleton: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    src: string;
+    singleton: boolean;
+}, {
+    src: string;
+    singleton?: boolean | undefined;
+}>>;

package/extensions/ProjectImplementation.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { defineExtension } from "../defineExtension/index.js";
+import { zodSrcPath } from "../defineExtension/zodTypes/zodSrcPath.js";
+export const ProjectImplementation = defineExtension({
+  type: "Project/Implementation",
+  tags: {
+    runtimeContext: "project"
+  },
+  multiple: true,
+  description: "Define a custom implementation or replace an existing one.",
+  paramsSchema: ({
+    project
+  }) => {
+    return z.object({
+      src: zodSrcPath({
+        project
+      }),
+      singleton: z.boolean().optional().default(true)
+    });
+  }
+});
+
+//# sourceMappingURL=ProjectImplementation.js.map

package/extensions/ProjectImplementation.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["z","defineExtension","zodSrcPath","ProjectImplementation","type","tags","runtimeContext","multiple","description","paramsSchema","project","object","src","singleton","boolean","optional","default"],"sources":["ProjectImplementation.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { defineExtension } from \"../defineExtension/index.js\";\nimport { zodSrcPath } from \"../defineExtension/zodTypes/zodSrcPath.js\";\n\nexport const ProjectImplementation = defineExtension({\n    type: \"Project/Implementation\",\n    tags: { runtimeContext: \"project\" },\n    multiple: true,\n    description: \"Define a custom implementation or replace an existing one.\",\n    paramsSchema: ({ project }) => {\n        return z.object({\n            src: zodSrcPath({ project }),\n            singleton: z.boolean().optional().default(true)\n        });\n    }\n});\n"],"mappings":"AAAA,SAASA,CAAC,QAAQ,KAAK;AACvB,SAASC,eAAe;AACxB,SAASC,UAAU;AAEnB,OAAO,MAAMC,qBAAqB,GAAGF,eAAe,CAAC;EACjDG,IAAI,EAAE,wBAAwB;EAC9BC,IAAI,EAAE;IAAEC,cAAc,EAAE;EAAU,CAAC;EACnCC,QAAQ,EAAE,IAAI;EACdC,WAAW,EAAE,4DAA4D;EACzEC,YAAY,EAAEA,CAAC;IAAEC;EAAQ,CAAC,KAAK;IAC3B,OAAOV,CAAC,CAACW,MAAM,CAAC;MACZC,GAAG,EAAEV,UAAU,CAAC;QAAEQ;MAAQ,CAAC,CAAC;MAC5BG,SAAS,EAAEb,CAAC,CAACc,OAAO,CAAC,CAAC,CAACC,QAAQ,CAAC,CAAC,CAACC,OAAO,CAAC,IAAI;IAClD,CAAC,CAAC;EACN;AACJ,CAAC,CAAC","ignoreList":[]}

package/extensions/Telemetry.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const Telemetry: import("../defineExtension/defineExtension.js").ExtensionComponent<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+}, {
+    enabled?: boolean | undefined;
+}>>;

package/extensions/Telemetry.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { defineExtension } from "../defineExtension/defineExtension.js";
+export const Telemetry = defineExtension({
+  type: "Project/Telemetry",
+  tags: {
+    runtimeContext: "project"
+  },
+  description: "This extension allows you to enable or disable telemetry for the project.",
+  paramsSchema: z.object({
+    enabled: z.boolean().default(true)
+  })
+});
+
+//# sourceMappingURL=Telemetry.js.map

package/extensions/Telemetry.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["z","defineExtension","Telemetry","type","tags","runtimeContext","description","paramsSchema","object","enabled","boolean","default"],"sources":["Telemetry.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { defineExtension } from \"../defineExtension/defineExtension.js\";\n\nexport const Telemetry = defineExtension({\n    type: \"Project/Telemetry\",\n    tags: { runtimeContext: \"project\" },\n    description: \"This extension allows you to enable or disable telemetry for the project.\",\n    paramsSchema: z.object({\n        enabled: z.boolean().default(true)\n    })\n});\n"],"mappings":"AAAA,SAASA,CAAC,QAAQ,KAAK;AACvB,SAASC,eAAe;AAExB,OAAO,MAAMC,SAAS,GAAGD,eAAe,CAAC;EACrCE,IAAI,EAAE,mBAAmB;EACzBC,IAAI,EAAE;IAAEC,cAAc,EAAE;EAAU,CAAC;EACnCC,WAAW,EAAE,2EAA2E;EACxFC,YAAY,EAAEP,CAAC,CAACQ,MAAM,CAAC;IACnBC,OAAO,EAAET,CAAC,CAACU,OAAO,CAAC,CAAC,CAACC,OAAO,CAAC,IAAI;EACrC,CAAC;AACL,CAAC,CAAC","ignoreList":[]}

package/extensions/hooks/AdminAfterBuild.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const AdminAfterBuild: import("~/defineExtension/index.js").ExtensionComponent<z.ZodObject<{
+    src: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+}, "strip", z.ZodTypeAny, {
+    src: string;
+}, {
+    src: string;
+}>>;

package/extensions/hooks/AdminAfterBuild.js

@@ -0,0 +1,25 @@
+import { defineExtension } from "../../defineExtension/index.js";
+import { zodSrcPath } from "../../defineExtension/zodTypes/zodSrcPath.js";
+import { AdminAfterBuild as AdminAfterBuildAbstraction } from "../../abstractions/index.js";
+import { z } from "zod";
+export const AdminAfterBuild = defineExtension({
+  type: "Admin/AfterBuild",
+  tags: {
+    runtimeContext: "project",
+    application: "admin"
+  },
+  description: "Add custom logic to be executed after the ADMIN build process.",
+  multiple: true,
+  paramsSchema: ({
+    project
+  }) => {
+    return z.object({
+      src: zodSrcPath({
+        project,
+        abstraction: AdminAfterBuildAbstraction
+      })
+    });
+  }
+});
+
+//# sourceMappingURL=AdminAfterBuild.js.map

package/extensions/hooks/AdminAfterBuild.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["defineExtension","zodSrcPath","AdminAfterBuild","AdminAfterBuildAbstraction","z","type","tags","runtimeContext","application","description","multiple","paramsSchema","project","object","src","abstraction"],"sources":["AdminAfterBuild.ts"],"sourcesContent":["import { defineExtension } from \"~/defineExtension/index.js\";\nimport { zodSrcPath } from \"~/defineExtension/zodTypes/zodSrcPath.js\";\nimport { AdminAfterBuild as AdminAfterBuildAbstraction } from \"~/abstractions/index.js\";\nimport { z } from \"zod\";\n\nexport const AdminAfterBuild = defineExtension({\n    type: \"Admin/AfterBuild\",\n    tags: { runtimeContext: \"project\", application: \"admin\" },\n    description: \"Add custom logic to be executed after the ADMIN build process.\",\n    multiple: true,\n    paramsSchema: ({ project }) => {\n        return z.object({\n            src: zodSrcPath({ project, abstraction: AdminAfterBuildAbstraction })\n        });\n    }\n});\n"],"mappings":"AAAA,SAASA,eAAe;AACxB,SAASC,UAAU;AACnB,SAASC,eAAe,IAAIC,0BAA0B;AACtD,SAASC,CAAC,QAAQ,KAAK;AAEvB,OAAO,MAAMF,eAAe,GAAGF,eAAe,CAAC;EAC3CK,IAAI,EAAE,kBAAkB;EACxBC,IAAI,EAAE;IAAEC,cAAc,EAAE,SAAS;IAAEC,WAAW,EAAE;EAAQ,CAAC;EACzDC,WAAW,EAAE,gEAAgE;EAC7EC,QAAQ,EAAE,IAAI;EACdC,YAAY,EAAEA,CAAC;IAAEC;EAAQ,CAAC,KAAK;IAC3B,OAAOR,CAAC,CAACS,MAAM,CAAC;MACZC,GAAG,EAAEb,UAAU,CAAC;QAAEW,OAAO;QAAEG,WAAW,EAAEZ;MAA2B,CAAC;IACxE,CAAC,CAAC;EACN;AACJ,CAAC,CAAC","ignoreList":[]}

package/extensions/hooks/AdminAfterDeploy.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const AdminAfterDeploy: import("~/defineExtension/index.js").ExtensionComponent<z.ZodObject<{
+    src: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+}, "strip", z.ZodTypeAny, {
+    src: string;
+}, {
+    src: string;
+}>>;

package/extensions/hooks/AdminAfterDeploy.js

@@ -0,0 +1,25 @@
+import { defineExtension } from "../../defineExtension/index.js";
+import { zodSrcPath } from "../../defineExtension/zodTypes/zodSrcPath.js";
+import { AdminAfterDeploy as AdminAfterDeployAbstraction } from "../../abstractions/index.js";
+import { z } from "zod";
+export const AdminAfterDeploy = defineExtension({
+  type: "Admin/AfterDeploy",
+  tags: {
+    runtimeContext: "project",
+    application: "admin"
+  },
+  description: "Add custom logic to be executed after the ADMIN deployment process.",
+  multiple: true,
+  paramsSchema: ({
+    project
+  }) => {
+    return z.object({
+      src: zodSrcPath({
+        project,
+        abstraction: AdminAfterDeployAbstraction
+      })
+    });
+  }
+});
+
+//# sourceMappingURL=AdminAfterDeploy.js.map

package/extensions/hooks/AdminAfterDeploy.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["defineExtension","zodSrcPath","AdminAfterDeploy","AdminAfterDeployAbstraction","z","type","tags","runtimeContext","application","description","multiple","paramsSchema","project","object","src","abstraction"],"sources":["AdminAfterDeploy.ts"],"sourcesContent":["import { defineExtension } from \"~/defineExtension/index.js\";\nimport { zodSrcPath } from \"~/defineExtension/zodTypes/zodSrcPath.js\";\nimport { AdminAfterDeploy as AdminAfterDeployAbstraction } from \"~/abstractions/index.js\";\nimport { z } from \"zod\";\n\nexport const AdminAfterDeploy = defineExtension({\n    type: \"Admin/AfterDeploy\",\n    tags: { runtimeContext: \"project\", application: \"admin\" },\n    description: \"Add custom logic to be executed after the ADMIN deployment process.\",\n    multiple: true,\n    paramsSchema: ({ project }) => {\n        return z.object({\n            src: zodSrcPath({ project, abstraction: AdminAfterDeployAbstraction })\n        });\n    }\n});\n"],"mappings":"AAAA,SAASA,eAAe;AACxB,SAASC,UAAU;AACnB,SAASC,gBAAgB,IAAIC,2BAA2B;AACxD,SAASC,CAAC,QAAQ,KAAK;AAEvB,OAAO,MAAMF,gBAAgB,GAAGF,eAAe,CAAC;EAC5CK,IAAI,EAAE,mBAAmB;EACzBC,IAAI,EAAE;IAAEC,cAAc,EAAE,SAAS;IAAEC,WAAW,EAAE;EAAQ,CAAC;EACzDC,WAAW,EAAE,qEAAqE;EAClFC,QAAQ,EAAE,IAAI;EACdC,YAAY,EAAEA,CAAC;IAAEC;EAAQ,CAAC,KAAK;IAC3B,OAAOR,CAAC,CAACS,MAAM,CAAC;MACZC,GAAG,EAAEb,UAAU,CAAC;QAAEW,OAAO;QAAEG,WAAW,EAAEZ;MAA4B,CAAC;IACzE,CAAC,CAAC;EACN;AACJ,CAAC,CAAC","ignoreList":[]}

package/extensions/hooks/AdminBeforeBuild.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const AdminBeforeBuild: import("~/defineExtension/index.js").ExtensionComponent<z.ZodObject<{
+    src: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+}, "strip", z.ZodTypeAny, {
+    src: string;
+}, {
+    src: string;
+}>>;

package/extensions/hooks/AdminBeforeBuild.js

@@ -0,0 +1,25 @@
+import { defineExtension } from "../../defineExtension/index.js";
+import { zodSrcPath } from "../../defineExtension/zodTypes/zodSrcPath.js";
+import { AdminBeforeBuild as AdminBeforeBuildAbstraction } from "../../abstractions/index.js";
+import { z } from "zod";
+export const AdminBeforeBuild = defineExtension({
+  type: "Admin/BeforeBuild",
+  tags: {
+    runtimeContext: "project",
+    application: "admin"
+  },
+  description: "Add custom logic to be executed before the ADMIN build process.",
+  multiple: true,
+  paramsSchema: ({
+    project
+  }) => {
+    return z.object({
+      src: zodSrcPath({
+        project,
+        abstraction: AdminBeforeBuildAbstraction
+      })
+    });
+  }
+});
+
+//# sourceMappingURL=AdminBeforeBuild.js.map

package/extensions/hooks/AdminBeforeBuild.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["defineExtension","zodSrcPath","AdminBeforeBuild","AdminBeforeBuildAbstraction","z","type","tags","runtimeContext","application","description","multiple","paramsSchema","project","object","src","abstraction"],"sources":["AdminBeforeBuild.ts"],"sourcesContent":["import { defineExtension } from \"~/defineExtension/index.js\";\nimport { zodSrcPath } from \"~/defineExtension/zodTypes/zodSrcPath.js\";\nimport { AdminBeforeBuild as AdminBeforeBuildAbstraction } from \"~/abstractions/index.js\";\nimport { z } from \"zod\";\n\nexport const AdminBeforeBuild = defineExtension({\n    type: \"Admin/BeforeBuild\",\n    tags: { runtimeContext: \"project\", application: \"admin\" },\n    description: \"Add custom logic to be executed before the ADMIN build process.\",\n    multiple: true,\n    paramsSchema: ({ project }) => {\n        return z.object({\n            src: zodSrcPath({ project, abstraction: AdminBeforeBuildAbstraction })\n        });\n    }\n});\n"],"mappings":"AAAA,SAASA,eAAe;AACxB,SAASC,UAAU;AACnB,SAASC,gBAAgB,IAAIC,2BAA2B;AACxD,SAASC,CAAC,QAAQ,KAAK;AAEvB,OAAO,MAAMF,gBAAgB,GAAGF,eAAe,CAAC;EAC5CK,IAAI,EAAE,mBAAmB;EACzBC,IAAI,EAAE;IAAEC,cAAc,EAAE,SAAS;IAAEC,WAAW,EAAE;EAAQ,CAAC;EACzDC,WAAW,EAAE,iEAAiE;EAC9EC,QAAQ,EAAE,IAAI;EACdC,YAAY,EAAEA,CAAC;IAAEC;EAAQ,CAAC,KAAK;IAC3B,OAAOR,CAAC,CAACS,MAAM,CAAC;MACZC,GAAG,EAAEb,UAAU,CAAC;QAAEW,OAAO;QAAEG,WAAW,EAAEZ;MAA4B,CAAC;IACzE,CAAC,CAAC;EACN;AACJ,CAAC,CAAC","ignoreList":[]}

package/extensions/hooks/AdminBeforeDeploy.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const AdminBeforeDeploy: import("~/defineExtension/index.js").ExtensionComponent<z.ZodObject<{
+    src: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+}, "strip", z.ZodTypeAny, {
+    src: string;
+}, {
+    src: string;
+}>>;

package/extensions/hooks/AdminBeforeDeploy.js

@@ -0,0 +1,25 @@
+import { defineExtension } from "../../defineExtension/index.js";
+import { zodSrcPath } from "../../defineExtension/zodTypes/zodSrcPath.js";
+import { AdminBeforeDeploy as AdminBeforeDeployAbstraction } from "../../abstractions/index.js";
+import { z } from "zod";
+export const AdminBeforeDeploy = defineExtension({
+  type: "Admin/BeforeDeploy",
+  tags: {
+    runtimeContext: "project",
+    application: "admin"
+  },
+  description: "Add custom logic to be executed before the ADMIN deployment process.",
+  multiple: true,
+  paramsSchema: ({
+    project
+  }) => {
+    return z.object({
+      src: zodSrcPath({
+        project,
+        abstraction: AdminBeforeDeployAbstraction
+      })
+    });
+  }
+});
+
+//# sourceMappingURL=AdminBeforeDeploy.js.map

package/extensions/hooks/AdminBeforeDeploy.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["defineExtension","zodSrcPath","AdminBeforeDeploy","AdminBeforeDeployAbstraction","z","type","tags","runtimeContext","application","description","multiple","paramsSchema","project","object","src","abstraction"],"sources":["AdminBeforeDeploy.ts"],"sourcesContent":["import { defineExtension } from \"~/defineExtension/index.js\";\nimport { zodSrcPath } from \"~/defineExtension/zodTypes/zodSrcPath.js\";\nimport { AdminBeforeDeploy as AdminBeforeDeployAbstraction } from \"~/abstractions/index.js\";\nimport { z } from \"zod\";\n\nexport const AdminBeforeDeploy = defineExtension({\n    type: \"Admin/BeforeDeploy\",\n    tags: { runtimeContext: \"project\", application: \"admin\" },\n    description: \"Add custom logic to be executed before the ADMIN deployment process.\",\n    multiple: true,\n    paramsSchema: ({ project }) => {\n        return z.object({\n            src: zodSrcPath({ project, abstraction: AdminBeforeDeployAbstraction })\n        });\n    }\n});\n"],"mappings":"AAAA,SAASA,eAAe;AACxB,SAASC,UAAU;AACnB,SAASC,iBAAiB,IAAIC,4BAA4B;AAC1D,SAASC,CAAC,QAAQ,KAAK;AAEvB,OAAO,MAAMF,iBAAiB,GAAGF,eAAe,CAAC;EAC7CK,IAAI,EAAE,oBAAoB;EAC1BC,IAAI,EAAE;IAAEC,cAAc,EAAE,SAAS;IAAEC,WAAW,EAAE;EAAQ,CAAC;EACzDC,WAAW,EAAE,sEAAsE;EACnFC,QAAQ,EAAE,IAAI;EACdC,YAAY,EAAEA,CAAC;IAAEC;EAAQ,CAAC,KAAK;IAC3B,OAAOR,CAAC,CAACS,MAAM,CAAC;MACZC,GAAG,EAAEb,UAAU,CAAC;QAAEW,OAAO;QAAEG,WAAW,EAAEZ;MAA6B,CAAC;IAC1E,CAAC,CAAC;EACN;AACJ,CAAC,CAAC","ignoreList":[]}

package/extensions/hooks/AdminBeforeWatch.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const AdminBeforeWatch: import("~/defineExtension/index.js").ExtensionComponent<z.ZodObject<{
+    src: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+}, "strip", z.ZodTypeAny, {
+    src: string;
+}, {
+    src: string;
+}>>;

package/extensions/hooks/AdminBeforeWatch.js

@@ -0,0 +1,25 @@
+import { defineExtension } from "../../defineExtension/index.js";
+import { zodSrcPath } from "../../defineExtension/zodTypes/zodSrcPath.js";
+import { AdminBeforeWatch as AdminBeforeWatchAbstraction } from "../../abstractions/index.js";
+import { z } from "zod";
+export const AdminBeforeWatch = defineExtension({
+  type: "Admin/BeforeWatch",
+  tags: {
+    runtimeContext: "project",
+    application: "admin"
+  },
+  description: "Add custom logic to be executed before the Admin watch process.",
+  multiple: true,
+  paramsSchema: ({
+    project
+  }) => {
+    return z.object({
+      src: zodSrcPath({
+        project,
+        abstraction: AdminBeforeWatchAbstraction
+      })
+    });
+  }
+});
+
+//# sourceMappingURL=AdminBeforeWatch.js.map

package/extensions/hooks/AdminBeforeWatch.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["defineExtension","zodSrcPath","AdminBeforeWatch","AdminBeforeWatchAbstraction","z","type","tags","runtimeContext","application","description","multiple","paramsSchema","project","object","src","abstraction"],"sources":["AdminBeforeWatch.ts"],"sourcesContent":["import { defineExtension } from \"~/defineExtension/index.js\";\nimport { zodSrcPath } from \"~/defineExtension/zodTypes/zodSrcPath.js\";\nimport { AdminBeforeWatch as AdminBeforeWatchAbstraction } from \"~/abstractions/index.js\";\nimport { z } from \"zod\";\n\nexport const AdminBeforeWatch = defineExtension({\n    type: \"Admin/BeforeWatch\",\n    tags: { runtimeContext: \"project\", application: \"admin\" },\n    description: \"Add custom logic to be executed before the Admin watch process.\",\n    multiple: true,\n    paramsSchema: ({ project }) => {\n        return z.object({\n            src: zodSrcPath({ project, abstraction: AdminBeforeWatchAbstraction })\n        });\n    }\n});\n"],"mappings":"AAAA,SAASA,eAAe;AACxB,SAASC,UAAU;AACnB,SAASC,gBAAgB,IAAIC,2BAA2B;AACxD,SAASC,CAAC,QAAQ,KAAK;AAEvB,OAAO,MAAMF,gBAAgB,GAAGF,eAAe,CAAC;EAC5CK,IAAI,EAAE,mBAAmB;EACzBC,IAAI,EAAE;IAAEC,cAAc,EAAE,SAAS;IAAEC,WAAW,EAAE;EAAQ,CAAC;EACzDC,WAAW,EAAE,iEAAiE;EAC9EC,QAAQ,EAAE,IAAI;EACdC,YAAY,EAAEA,CAAC;IAAEC;EAAQ,CAAC,KAAK;IAC3B,OAAOR,CAAC,CAACS,MAAM,CAAC;MACZC,GAAG,EAAEb,UAAU,CAAC;QAAEW,OAAO;QAAEG,WAAW,EAAEZ;MAA4B,CAAC;IACzE,CAAC,CAAC;EACN;AACJ,CAAC,CAAC","ignoreList":[]}

package/extensions/hooks/AfterBuild.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const AfterBuild: import("~/defineExtension/index.js").ExtensionComponent<z.ZodObject<{
+    src: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+}, "strip", z.ZodTypeAny, {
+    src: string;
+}, {
+    src: string;
+}>>;

package/extensions/hooks/AfterBuild.js

@@ -0,0 +1,24 @@
+import { defineExtension } from "../../defineExtension/index.js";
+import { zodSrcPath } from "../../defineExtension/zodTypes/zodSrcPath.js";
+import { AfterBuild as AfterBuildAbstraction } from "../../abstractions/index.js";
+import { z } from "zod";
+export const AfterBuild = defineExtension({
+  type: "Project/AfterBuild",
+  tags: {
+    runtimeContext: "project"
+  },
+  description: "Add custom logic to be executed after the PROJECT build process.",
+  multiple: true,
+  paramsSchema: ({
+    project
+  }) => {
+    return z.object({
+      src: zodSrcPath({
+        project,
+        abstraction: AfterBuildAbstraction
+      })
+    });
+  }
+});
+
+//# sourceMappingURL=AfterBuild.js.map

package/extensions/hooks/AfterBuild.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["defineExtension","zodSrcPath","AfterBuild","AfterBuildAbstraction","z","type","tags","runtimeContext","description","multiple","paramsSchema","project","object","src","abstraction"],"sources":["AfterBuild.ts"],"sourcesContent":["import { defineExtension } from \"~/defineExtension/index.js\";\nimport { zodSrcPath } from \"~/defineExtension/zodTypes/zodSrcPath.js\";\nimport { AfterBuild as AfterBuildAbstraction } from \"~/abstractions/index.js\";\nimport { z } from \"zod\";\n\nexport const AfterBuild = defineExtension({\n    type: \"Project/AfterBuild\",\n    tags: { runtimeContext: \"project\" },\n    description: \"Add custom logic to be executed after the PROJECT build process.\",\n    multiple: true,\n    paramsSchema: ({ project }) => {\n        return z.object({\n            src: zodSrcPath({ project, abstraction: AfterBuildAbstraction })\n        });\n    }\n});\n"],"mappings":"AAAA,SAASA,eAAe;AACxB,SAASC,UAAU;AACnB,SAASC,UAAU,IAAIC,qBAAqB;AAC5C,SAASC,CAAC,QAAQ,KAAK;AAEvB,OAAO,MAAMF,UAAU,GAAGF,eAAe,CAAC;EACtCK,IAAI,EAAE,oBAAoB;EAC1BC,IAAI,EAAE;IAAEC,cAAc,EAAE;EAAU,CAAC;EACnCC,WAAW,EAAE,kEAAkE;EAC/EC,QAAQ,EAAE,IAAI;EACdC,YAAY,EAAEA,CAAC;IAAEC;EAAQ,CAAC,KAAK;IAC3B,OAAOP,CAAC,CAACQ,MAAM,CAAC;MACZC,GAAG,EAAEZ,UAAU,CAAC;QAAEU,OAAO;QAAEG,WAAW,EAAEX;MAAsB,CAAC;IACnE,CAAC,CAAC;EACN;AACJ,CAAC,CAAC","ignoreList":[]}

package/extensions/hooks/AfterDeploy.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const AfterDeploy: import("~/defineExtension/index.js").ExtensionComponent<z.ZodObject<{
+    src: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+}, "strip", z.ZodTypeAny, {
+    src: string;
+}, {
+    src: string;
+}>>;

package/extensions/hooks/AfterDeploy.js

@@ -0,0 +1,24 @@
+import { defineExtension } from "../../defineExtension/index.js";
+import { zodSrcPath } from "../../defineExtension/zodTypes/zodSrcPath.js";
+import { AfterDeploy as AfterDeployAbstraction } from "../../abstractions/index.js";
+import { z } from "zod";
+export const AfterDeploy = defineExtension({
+  type: "Project/AfterDeploy",
+  tags: {
+    runtimeContext: "project"
+  },
+  description: "Add custom logic to be executed after the PROJECT deploy process.",
+  multiple: true,
+  paramsSchema: ({
+    project
+  }) => {
+    return z.object({
+      src: zodSrcPath({
+        project,
+        abstraction: AfterDeployAbstraction
+      })
+    });
+  }
+});
+
+//# sourceMappingURL=AfterDeploy.js.map

package/extensions/hooks/AfterDeploy.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["defineExtension","zodSrcPath","AfterDeploy","AfterDeployAbstraction","z","type","tags","runtimeContext","description","multiple","paramsSchema","project","object","src","abstraction"],"sources":["AfterDeploy.ts"],"sourcesContent":["import { defineExtension } from \"~/defineExtension/index.js\";\nimport { zodSrcPath } from \"~/defineExtension/zodTypes/zodSrcPath.js\";\nimport { AfterDeploy as AfterDeployAbstraction } from \"~/abstractions/index.js\";\nimport { z } from \"zod\";\n\nexport const AfterDeploy = defineExtension({\n    type: \"Project/AfterDeploy\",\n    tags: { runtimeContext: \"project\" },\n    description: \"Add custom logic to be executed after the PROJECT deploy process.\",\n    multiple: true,\n    paramsSchema: ({ project }) => {\n        return z.object({\n            src: zodSrcPath({ project, abstraction: AfterDeployAbstraction })\n        });\n    }\n});\n"],"mappings":"AAAA,SAASA,eAAe;AACxB,SAASC,UAAU;AACnB,SAASC,WAAW,IAAIC,sBAAsB;AAC9C,SAASC,CAAC,QAAQ,KAAK;AAEvB,OAAO,MAAMF,WAAW,GAAGF,eAAe,CAAC;EACvCK,IAAI,EAAE,qBAAqB;EAC3BC,IAAI,EAAE;IAAEC,cAAc,EAAE;EAAU,CAAC;EACnCC,WAAW,EAAE,mEAAmE;EAChFC,QAAQ,EAAE,IAAI;EACdC,YAAY,EAAEA,CAAC;IAAEC;EAAQ,CAAC,KAAK;IAC3B,OAAOP,CAAC,CAACQ,MAAM,CAAC;MACZC,GAAG,EAAEZ,UAAU,CAAC;QAAEU,OAAO;QAAEG,WAAW,EAAEX;MAAuB,CAAC;IACpE,CAAC,CAAC;EACN;AACJ,CAAC,CAAC","ignoreList":[]}

package/extensions/hooks/ApiAfterBuild.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const ApiAfterBuild: import("~/defineExtension/index.js").ExtensionComponent<z.ZodObject<{
+    src: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+}, "strip", z.ZodTypeAny, {
+    src: string;
+}, {
+    src: string;
+}>>;

package/extensions/hooks/ApiAfterBuild.js

@@ -0,0 +1,25 @@
+import { defineExtension } from "../../defineExtension/index.js";
+import { zodSrcPath } from "../../defineExtension/zodTypes/zodSrcPath.js";
+import { ApiAfterBuild as ApiAfterBuildAbstraction } from "../../abstractions/index.js";
+import { z } from "zod";
+export const ApiAfterBuild = defineExtension({
+  type: "Api/AfterBuild",
+  tags: {
+    runtimeContext: "project",
+    application: "api"
+  },
+  description: "Add custom logic to be executed after the API build process.",
+  multiple: true,
+  paramsSchema: ({
+    project
+  }) => {
+    return z.object({
+      src: zodSrcPath({
+        project,
+        abstraction: ApiAfterBuildAbstraction
+      })
+    });
+  }
+});
+
+//# sourceMappingURL=ApiAfterBuild.js.map

package/extensions/hooks/ApiAfterBuild.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["defineExtension","zodSrcPath","ApiAfterBuild","ApiAfterBuildAbstraction","z","type","tags","runtimeContext","application","description","multiple","paramsSchema","project","object","src","abstraction"],"sources":["ApiAfterBuild.ts"],"sourcesContent":["import { defineExtension } from \"~/defineExtension/index.js\";\nimport { zodSrcPath } from \"~/defineExtension/zodTypes/zodSrcPath.js\";\nimport { ApiAfterBuild as ApiAfterBuildAbstraction } from \"~/abstractions/index.js\";\nimport { z } from \"zod\";\n\nexport const ApiAfterBuild = defineExtension({\n    type: \"Api/AfterBuild\",\n    tags: { runtimeContext: \"project\", application: \"api\" },\n    description: \"Add custom logic to be executed after the API build process.\",\n    multiple: true,\n    paramsSchema: ({ project }) => {\n        return z.object({\n            src: zodSrcPath({ project, abstraction: ApiAfterBuildAbstraction })\n        });\n    }\n});\n"],"mappings":"AAAA,SAASA,eAAe;AACxB,SAASC,UAAU;AACnB,SAASC,aAAa,IAAIC,wBAAwB;AAClD,SAASC,CAAC,QAAQ,KAAK;AAEvB,OAAO,MAAMF,aAAa,GAAGF,eAAe,CAAC;EACzCK,IAAI,EAAE,gBAAgB;EACtBC,IAAI,EAAE;IAAEC,cAAc,EAAE,SAAS;IAAEC,WAAW,EAAE;EAAM,CAAC;EACvDC,WAAW,EAAE,8DAA8D;EAC3EC,QAAQ,EAAE,IAAI;EACdC,YAAY,EAAEA,CAAC;IAAEC;EAAQ,CAAC,KAAK;IAC3B,OAAOR,CAAC,CAACS,MAAM,CAAC;MACZC,GAAG,EAAEb,UAAU,CAAC;QAAEW,OAAO;QAAEG,WAAW,EAAEZ;MAAyB,CAAC;IACtE,CAAC,CAAC;EACN;AACJ,CAAC,CAAC","ignoreList":[]}

package/extensions/hooks/ApiAfterDeploy.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const ApiAfterDeploy: import("~/defineExtension/index.js").ExtensionComponent<z.ZodObject<{
+    src: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+}, "strip", z.ZodTypeAny, {
+    src: string;
+}, {
+    src: string;
+}>>;

package/extensions/hooks/ApiAfterDeploy.js

@@ -0,0 +1,25 @@
+import { defineExtension } from "../../defineExtension/index.js";
+import { zodSrcPath } from "../../defineExtension/zodTypes/zodSrcPath.js";
+import { ApiAfterDeploy as ApiAfterDeployAbstraction } from "../../abstractions/index.js";
+import { z } from "zod";
+export const ApiAfterDeploy = defineExtension({
+  type: "Api/AfterDeploy",
+  tags: {
+    runtimeContext: "project",
+    application: "api"
+  },
+  description: "Add custom logic to be executed after the API deployment process.",
+  multiple: true,
+  paramsSchema: ({
+    project
+  }) => {
+    return z.object({
+      src: zodSrcPath({
+        project,
+        abstraction: ApiAfterDeployAbstraction
+      })
+    });
+  }
+});
+
+//# sourceMappingURL=ApiAfterDeploy.js.map

package/extensions/hooks/ApiAfterDeploy.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["defineExtension","zodSrcPath","ApiAfterDeploy","ApiAfterDeployAbstraction","z","type","tags","runtimeContext","application","description","multiple","paramsSchema","project","object","src","abstraction"],"sources":["ApiAfterDeploy.ts"],"sourcesContent":["import { defineExtension } from \"~/defineExtension/index.js\";\nimport { zodSrcPath } from \"~/defineExtension/zodTypes/zodSrcPath.js\";\nimport { ApiAfterDeploy as ApiAfterDeployAbstraction } from \"~/abstractions/index.js\";\nimport { z } from \"zod\";\n\nexport const ApiAfterDeploy = defineExtension({\n    type: \"Api/AfterDeploy\",\n    tags: { runtimeContext: \"project\", application: \"api\" },\n    description: \"Add custom logic to be executed after the API deployment process.\",\n    multiple: true,\n    paramsSchema: ({ project }) => {\n        return z.object({\n            src: zodSrcPath({ project, abstraction: ApiAfterDeployAbstraction })\n        });\n    }\n});\n"],"mappings":"AAAA,SAASA,eAAe;AACxB,SAASC,UAAU;AACnB,SAASC,cAAc,IAAIC,yBAAyB;AACpD,SAASC,CAAC,QAAQ,KAAK;AAEvB,OAAO,MAAMF,cAAc,GAAGF,eAAe,CAAC;EAC1CK,IAAI,EAAE,iBAAiB;EACvBC,IAAI,EAAE;IAAEC,cAAc,EAAE,SAAS;IAAEC,WAAW,EAAE;EAAM,CAAC;EACvDC,WAAW,EAAE,mEAAmE;EAChFC,QAAQ,EAAE,IAAI;EACdC,YAAY,EAAEA,CAAC;IAAEC;EAAQ,CAAC,KAAK;IAC3B,OAAOR,CAAC,CAACS,MAAM,CAAC;MACZC,GAAG,EAAEb,UAAU,CAAC;QAAEW,OAAO;QAAEG,WAAW,EAAEZ;MAA0B,CAAC;IACvE,CAAC,CAAC;EACN;AACJ,CAAC,CAAC","ignoreList":[]}

package/extensions/hooks/ApiBeforeBuild.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const ApiBeforeBuild: import("~/defineExtension/index.js").ExtensionComponent<z.ZodObject<{
+    src: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+}, "strip", z.ZodTypeAny, {
+    src: string;
+}, {
+    src: string;
+}>>;

package/extensions/hooks/ApiBeforeBuild.js

@@ -0,0 +1,25 @@
+import { defineExtension } from "../../defineExtension/index.js";
+import { zodSrcPath } from "../../defineExtension/zodTypes/zodSrcPath.js";
+import { ApiBeforeBuild as ApiBeforeBuildAbstraction } from "../../abstractions/index.js";
+import { z } from "zod";
+export const ApiBeforeBuild = defineExtension({
+  type: "Api/BeforeBuild",
+  tags: {
+    runtimeContext: "project",
+    application: "api"
+  },
+  description: "Add custom logic to be executed before the API build process.",
+  multiple: true,
+  paramsSchema: ({
+    project
+  }) => {
+    return z.object({
+      src: zodSrcPath({
+        project,
+        abstraction: ApiBeforeBuildAbstraction
+      })
+    });
+  }
+});
+
+//# sourceMappingURL=ApiBeforeBuild.js.map

package/extensions/hooks/ApiBeforeBuild.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["defineExtension","zodSrcPath","ApiBeforeBuild","ApiBeforeBuildAbstraction","z","type","tags","runtimeContext","application","description","multiple","paramsSchema","project","object","src","abstraction"],"sources":["ApiBeforeBuild.ts"],"sourcesContent":["import { defineExtension } from \"~/defineExtension/index.js\";\nimport { zodSrcPath } from \"~/defineExtension/zodTypes/zodSrcPath.js\";\nimport { ApiBeforeBuild as ApiBeforeBuildAbstraction } from \"~/abstractions/index.js\";\nimport { z } from \"zod\";\n\nexport const ApiBeforeBuild = defineExtension({\n    type: \"Api/BeforeBuild\",\n    tags: { runtimeContext: \"project\", application: \"api\" },\n    description: \"Add custom logic to be executed before the API build process.\",\n    multiple: true,\n    paramsSchema: ({ project }) => {\n        return z.object({\n            src: zodSrcPath({ project, abstraction: ApiBeforeBuildAbstraction })\n        });\n    }\n});\n"],"mappings":"AAAA,SAASA,eAAe;AACxB,SAASC,UAAU;AACnB,SAASC,cAAc,IAAIC,yBAAyB;AACpD,SAASC,CAAC,QAAQ,KAAK;AAEvB,OAAO,MAAMF,cAAc,GAAGF,eAAe,CAAC;EAC1CK,IAAI,EAAE,iBAAiB;EACvBC,IAAI,EAAE;IAAEC,cAAc,EAAE,SAAS;IAAEC,WAAW,EAAE;EAAM,CAAC;EACvDC,WAAW,EAAE,+DAA+D;EAC5EC,QAAQ,EAAE,IAAI;EACdC,YAAY,EAAEA,CAAC;IAAEC;EAAQ,CAAC,KAAK;IAC3B,OAAOR,CAAC,CAACS,MAAM,CAAC;MACZC,GAAG,EAAEb,UAAU,CAAC;QAAEW,OAAO;QAAEG,WAAW,EAAEZ;MAA0B,CAAC;IACvE,CAAC,CAAC;EACN;AACJ,CAAC,CAAC","ignoreList":[]}

package/extensions/hooks/ApiBeforeDeploy.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const ApiBeforeDeploy: import("~/defineExtension/index.js").ExtensionComponent<z.ZodObject<{
+    src: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+}, "strip", z.ZodTypeAny, {
+    src: string;
+}, {
+    src: string;
+}>>;

package/extensions/hooks/ApiBeforeDeploy.js

@@ -0,0 +1,25 @@
+import { defineExtension } from "../../defineExtension/index.js";
+import { zodSrcPath } from "../../defineExtension/zodTypes/zodSrcPath.js";
+import { ApiBeforeDeploy as ApiBeforeDeployAbstraction } from "../../abstractions/index.js";
+import { z } from "zod";
+export const ApiBeforeDeploy = defineExtension({
+  type: "Api/BeforeDeploy",
+  tags: {
+    runtimeContext: "project",
+    application: "api"
+  },
+  description: "Add custom logic to be executed before the API deployment process.",
+  multiple: true,
+  paramsSchema: ({
+    project
+  }) => {
+    return z.object({
+      src: zodSrcPath({
+        project,
+        abstraction: ApiBeforeDeployAbstraction
+      })
+    });
+  }
+});
+
+//# sourceMappingURL=ApiBeforeDeploy.js.map

package/extensions/hooks/ApiBeforeDeploy.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["defineExtension","zodSrcPath","ApiBeforeDeploy","ApiBeforeDeployAbstraction","z","type","tags","runtimeContext","application","description","multiple","paramsSchema","project","object","src","abstraction"],"sources":["ApiBeforeDeploy.ts"],"sourcesContent":["import { defineExtension } from \"~/defineExtension/index.js\";\nimport { zodSrcPath } from \"~/defineExtension/zodTypes/zodSrcPath.js\";\nimport { ApiBeforeDeploy as ApiBeforeDeployAbstraction } from \"~/abstractions/index.js\";\nimport { z } from \"zod\";\n\nexport const ApiBeforeDeploy = defineExtension({\n    type: \"Api/BeforeDeploy\",\n    tags: { runtimeContext: \"project\", application: \"api\" },\n    description: \"Add custom logic to be executed before the API deployment process.\",\n    multiple: true,\n    paramsSchema: ({ project }) => {\n        return z.object({\n            src: zodSrcPath({ project, abstraction: ApiBeforeDeployAbstraction })\n        });\n    }\n});\n"],"mappings":"AAAA,SAASA,eAAe;AACxB,SAASC,UAAU;AACnB,SAASC,eAAe,IAAIC,0BAA0B;AACtD,SAASC,CAAC,QAAQ,KAAK;AAEvB,OAAO,MAAMF,eAAe,GAAGF,eAAe,CAAC;EAC3CK,IAAI,EAAE,kBAAkB;EACxBC,IAAI,EAAE;IAAEC,cAAc,EAAE,SAAS;IAAEC,WAAW,EAAE;EAAM,CAAC;EACvDC,WAAW,EAAE,oEAAoE;EACjFC,QAAQ,EAAE,IAAI;EACdC,YAAY,EAAEA,CAAC;IAAEC;EAAQ,CAAC,KAAK;IAC3B,OAAOR,CAAC,CAACS,MAAM,CAAC;MACZC,GAAG,EAAEb,UAAU,CAAC;QAAEW,OAAO;QAAEG,WAAW,EAAEZ;MAA2B,CAAC;IACxE,CAAC,CAAC;EACN;AACJ,CAAC,CAAC","ignoreList":[]}

package/extensions/hooks/ApiBeforeWatch.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const ApiBeforeWatch: import("~/defineExtension/index.js").ExtensionComponent<z.ZodObject<{
+    src: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+}, "strip", z.ZodTypeAny, {
+    src: string;
+}, {
+    src: string;
+}>>;

package/extensions/hooks/ApiBeforeWatch.js

@@ -0,0 +1,25 @@
+import { defineExtension } from "../../defineExtension/index.js";
+import { zodSrcPath } from "../../defineExtension/zodTypes/zodSrcPath.js";
+import { ApiBeforeWatch as ApiBeforeWatchAbstraction } from "../../abstractions/index.js";
+import { z } from "zod";
+export const ApiBeforeWatch = defineExtension({
+  type: "Api/BeforeWatch",
+  tags: {
+    runtimeContext: "project",
+    application: "api"
+  },
+  description: "Add custom logic to be executed before the API watch process.",
+  multiple: true,
+  paramsSchema: ({
+    project
+  }) => {
+    return z.object({
+      src: zodSrcPath({
+        project,
+        abstraction: ApiBeforeWatchAbstraction
+      })
+    });
+  }
+});
+
+//# sourceMappingURL=ApiBeforeWatch.js.map

package/extensions/hooks/ApiBeforeWatch.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["defineExtension","zodSrcPath","ApiBeforeWatch","ApiBeforeWatchAbstraction","z","type","tags","runtimeContext","application","description","multiple","paramsSchema","project","object","src","abstraction"],"sources":["ApiBeforeWatch.ts"],"sourcesContent":["import { defineExtension } from \"~/defineExtension/index.js\";\nimport { zodSrcPath } from \"~/defineExtension/zodTypes/zodSrcPath.js\";\nimport { ApiBeforeWatch as ApiBeforeWatchAbstraction } from \"~/abstractions/index.js\";\nimport { z } from \"zod\";\n\nexport const ApiBeforeWatch = defineExtension({\n    type: \"Api/BeforeWatch\",\n    tags: { runtimeContext: \"project\", application: \"api\" },\n    description: \"Add custom logic to be executed before the API watch process.\",\n    multiple: true,\n    paramsSchema: ({ project }) => {\n        return z.object({\n            src: zodSrcPath({ project, abstraction: ApiBeforeWatchAbstraction })\n        });\n    }\n});\n"],"mappings":"AAAA,SAASA,eAAe;AACxB,SAASC,UAAU;AACnB,SAASC,cAAc,IAAIC,yBAAyB;AACpD,SAASC,CAAC,QAAQ,KAAK;AAEvB,OAAO,MAAMF,cAAc,GAAGF,eAAe,CAAC;EAC1CK,IAAI,EAAE,iBAAiB;EACvBC,IAAI,EAAE;IAAEC,cAAc,EAAE,SAAS;IAAEC,WAAW,EAAE;EAAM,CAAC;EACvDC,WAAW,EAAE,+DAA+D;EAC5EC,QAAQ,EAAE,IAAI;EACdC,YAAY,EAAEA,CAAC;IAAEC;EAAQ,CAAC,KAAK;IAC3B,OAAOR,CAAC,CAACS,MAAM,CAAC;MACZC,GAAG,EAAEb,UAAU,CAAC;QAAEW,OAAO;QAAEG,WAAW,EAAEZ;MAA0B,CAAC;IACvE,CAAC,CAAC;EACN;AACJ,CAAC,CAAC","ignoreList":[]}

package/extensions/hooks/BeforeBuild.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const BeforeBuild: import("~/defineExtension/index.js").ExtensionComponent<z.ZodObject<{
+    src: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+}, "strip", z.ZodTypeAny, {
+    src: string;
+}, {
+    src: string;
+}>>;