@webiny/sdk 6.3.0 → 6.4.0-beta.1

package/methods/tenantManager/installTenant.js

@@ -3,19 +3,8 @@ import { createMethod } from "../../utils/createMethod.js";
 import { installTenantSchema } from "./schemas.js";
 import { executeGraphQL } from "../executeGraphQL.js";
 import { ApiError } from "../../errors.js";
-/**
- * Installs and provisions a tenant with default settings and configurations.
- *
- * @param config - SDK configuration
- * @param fetchFn - Fetch function to use for HTTP requests
- * @param params - Parameters for installing the tenant
- * @param params.tenantId - ID of the tenant to install
- * @returns Result containing true on success or an error
- */
-export const installTenant = createMethod(installTenantSchema, async (config, fetchFn, {
-  tenantId
-}) => {
-  const query = `
+const installTenant = createMethod(installTenantSchema, async (config, fetchFn, { tenantId })=>{
+    const query = `
         mutation InstallTenant($tenantId: ID!) {
             tenantManager {
                 installTenant(tenantId: $tenantId) {
@@ -28,17 +17,14 @@ export const installTenant = createMethod(installTenantSchema, async (config, fe
             }
         }
     `;
-  const result = await executeGraphQL(config, fetchFn, query, {
-    tenantId
-  });
-  if (result.isFail()) {
-    return Result.fail(result.error);
-  }
-  const responseData = result.value;
-  if (responseData.tenantManager.installTenant.error) {
-    return Result.fail(new ApiError(responseData.tenantManager.installTenant.error.message, responseData.tenantManager.installTenant.error.code));
-  }
-  return Result.ok(responseData.tenantManager.installTenant.data);
+    const result = await executeGraphQL(config, fetchFn, query, {
+        tenantId
+    });
+    if (result.isFail()) return Result.fail(result.error);
+    const responseData = result.value;
+    if (responseData.tenantManager.installTenant.error) return Result.fail(new ApiError(responseData.tenantManager.installTenant.error.message, responseData.tenantManager.installTenant.error.code));
+    return Result.ok(responseData.tenantManager.installTenant.data);
 });
+export { installTenant };
 
 //# sourceMappingURL=installTenant.js.map

package/methods/tenantManager/installTenant.js.map

@@ -1 +1 @@
-{"version":3,"names":["Result","createMethod","installTenantSchema","executeGraphQL","ApiError","installTenant","config","fetchFn","tenantId","query","result","isFail","fail","error","responseData","value","tenantManager","message","code","ok","data"],"sources":["installTenant.ts"],"sourcesContent":["import { Result } from \"../../Result.js\";\nimport { createMethod } from \"../../utils/createMethod.js\";\nimport { installTenantSchema } from \"./schemas.js\";\nimport { executeGraphQL } from \"../executeGraphQL.js\";\nimport { ApiError } from \"../../errors.js\";\n\nexport interface InstallTenantParams {\n    tenantId: string;\n}\n\n/**\n * Installs and provisions a tenant with default settings and configurations.\n *\n * @param config - SDK configuration\n * @param fetchFn - Fetch function to use for HTTP requests\n * @param params - Parameters for installing the tenant\n * @param params.tenantId - ID of the tenant to install\n * @returns Result containing true on success or an error\n */\nexport const installTenant = createMethod(\n    installTenantSchema,\n    async (config, fetchFn, { tenantId }) => {\n        const query = `\n        mutation InstallTenant($tenantId: ID!) {\n            tenantManager {\n                installTenant(tenantId: $tenantId) {\n                    data\n                    error {\n                        message\n                        code\n                    }\n                }\n            }\n        }\n    `;\n\n        const result = await executeGraphQL(config, fetchFn, query, { tenantId });\n\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        const responseData = result.value;\n\n        if (responseData.tenantManager.installTenant.error) {\n            return Result.fail(\n                new ApiError(\n                    responseData.tenantManager.installTenant.error.message,\n                    responseData.tenantManager.installTenant.error.code\n                )\n            );\n        }\n\n        return Result.ok(responseData.tenantManager.installTenant.data as boolean);\n    }\n);\n"],"mappings":"AAAA,SAASA,MAAM;AACf,SAASC,YAAY;AACrB,SAASC,mBAAmB;AAC5B,SAASC,cAAc;AACvB,SAASC,QAAQ;AAMjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,aAAa,GAAGJ,YAAY,CACrCC,mBAAmB,EACnB,OAAOI,MAAM,EAAEC,OAAO,EAAE;EAAEC;AAAS,CAAC,KAAK;EACrC,MAAMC,KAAK,GAAG;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;EAEG,MAAMC,MAAM,GAAG,MAAMP,cAAc,CAACG,MAAM,EAAEC,OAAO,EAAEE,KAAK,EAAE;IAAED;EAAS,CAAC,CAAC;EAEzE,IAAIE,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;IACjB,OAAOX,MAAM,CAACY,IAAI,CAACF,MAAM,CAACG,KAAK,CAAC;EACpC;EAEA,MAAMC,YAAY,GAAGJ,MAAM,CAACK,KAAK;EAEjC,IAAID,YAAY,CAACE,aAAa,CAACX,aAAa,CAACQ,KAAK,EAAE;IAChD,OAAOb,MAAM,CAACY,IAAI,CACd,IAAIR,QAAQ,CACRU,YAAY,CAACE,aAAa,CAACX,aAAa,CAACQ,KAAK,CAACI,OAAO,EACtDH,YAAY,CAACE,aAAa,CAACX,aAAa,CAACQ,KAAK,CAACK,IACnD,CACJ,CAAC;EACL;EAEA,OAAOlB,MAAM,CAACmB,EAAE,CAACL,YAAY,CAACE,aAAa,CAACX,aAAa,CAACe,IAAe,CAAC;AAC9E,CACJ,CAAC","ignoreList":[]}
+{"version":3,"file":"methods/tenantManager/installTenant.js","sources":["../../../src/methods/tenantManager/installTenant.ts"],"sourcesContent":["import { Result } from \"../../Result.js\";\nimport { createMethod } from \"../../utils/createMethod.js\";\nimport { installTenantSchema } from \"./schemas.js\";\nimport { executeGraphQL } from \"../executeGraphQL.js\";\nimport { ApiError } from \"../../errors.js\";\n\nexport interface InstallTenantParams {\n    tenantId: string;\n}\n\n/**\n * Installs and provisions a tenant with default settings and configurations.\n *\n * @param config - SDK configuration\n * @param fetchFn - Fetch function to use for HTTP requests\n * @param params - Parameters for installing the tenant\n * @param params.tenantId - ID of the tenant to install\n * @returns Result containing true on success or an error\n */\nexport const installTenant = createMethod(\n    installTenantSchema,\n    async (config, fetchFn, { tenantId }) => {\n        const query = `\n        mutation InstallTenant($tenantId: ID!) {\n            tenantManager {\n                installTenant(tenantId: $tenantId) {\n                    data\n                    error {\n                        message\n                        code\n                    }\n                }\n            }\n        }\n    `;\n\n        const result = await executeGraphQL(config, fetchFn, query, { tenantId });\n\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        const responseData = result.value;\n\n        if (responseData.tenantManager.installTenant.error) {\n            return Result.fail(\n                new ApiError(\n                    responseData.tenantManager.installTenant.error.message,\n                    responseData.tenantManager.installTenant.error.code\n                )\n            );\n        }\n\n        return Result.ok(responseData.tenantManager.installTenant.data as boolean);\n    }\n);\n"],"names":["installTenant","createMethod","installTenantSchema","config","fetchFn","tenantId","query","result","executeGraphQL","Result","responseData","ApiError"],"mappings":";;;;;AAmBO,MAAMA,gBAAgBC,aACzBC,qBACA,OAAOC,QAAQC,SAAS,EAAEC,QAAQ,EAAE;IAChC,MAAMC,QAAQ,CAAC;;;;;;;;;;;;IAYnB,CAAC;IAEG,MAAMC,SAAS,MAAMC,eAAeL,QAAQC,SAASE,OAAO;QAAED;IAAS;IAEvE,IAAIE,OAAO,MAAM,IACb,OAAOE,OAAO,IAAI,CAACF,OAAO,KAAK;IAGnC,MAAMG,eAAeH,OAAO,KAAK;IAEjC,IAAIG,aAAa,aAAa,CAAC,aAAa,CAAC,KAAK,EAC9C,OAAOD,OAAO,IAAI,CACd,IAAIE,SACAD,aAAa,aAAa,CAAC,aAAa,CAAC,KAAK,CAAC,OAAO,EACtDA,aAAa,aAAa,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI;IAK/D,OAAOD,OAAO,EAAE,CAACC,aAAa,aAAa,CAAC,aAAa,CAAC,IAAI;AAClE"}

package/methods/tenantManager/schemas.js

@@ -1,20 +1,21 @@
 import { z } from "zod";
 const tenantId = z.string().min(1, "tenantId is required");
-export const createTenantSchema = z.object({
-  data: z.object({
-    id: z.string().optional(),
-    name: z.string().min(1, "name is required"),
-    description: z.string().optional()
-  })
+const createTenantSchema = z.object({
+    data: z.object({
+        id: z.string().optional(),
+        name: z.string().min(1, "name is required"),
+        description: z.string().optional()
+    })
 });
-export const disableTenantSchema = z.object({
-  tenantId
+const disableTenantSchema = z.object({
+    tenantId: tenantId
 });
-export const enableTenantSchema = z.object({
-  tenantId
+const enableTenantSchema = z.object({
+    tenantId: tenantId
 });
-export const installTenantSchema = z.object({
-  tenantId
+const installTenantSchema = z.object({
+    tenantId: tenantId
 });
+export { createTenantSchema, disableTenantSchema, enableTenantSchema, installTenantSchema };
 
 //# sourceMappingURL=schemas.js.map

package/methods/tenantManager/schemas.js.map

@@ -1 +1 @@
-{"version":3,"names":["z","tenantId","string","min","createTenantSchema","object","data","id","optional","name","description","disableTenantSchema","enableTenantSchema","installTenantSchema"],"sources":["schemas.ts"],"sourcesContent":["import { z } from \"zod\";\n\nconst tenantId = z.string().min(1, \"tenantId is required\");\n\nexport const createTenantSchema = z.object({\n    data: z.object({\n        id: z.string().optional(),\n        name: z.string().min(1, \"name is required\"),\n        description: z.string().optional()\n    })\n});\n\nexport const disableTenantSchema = z.object({ tenantId });\nexport const enableTenantSchema = z.object({ tenantId });\nexport const installTenantSchema = z.object({ tenantId });\n"],"mappings":"AAAA,SAASA,CAAC,QAAQ,KAAK;AAEvB,MAAMC,QAAQ,GAAGD,CAAC,CAACE,MAAM,CAAC,CAAC,CAACC,GAAG,CAAC,CAAC,EAAE,sBAAsB,CAAC;AAE1D,OAAO,MAAMC,kBAAkB,GAAGJ,CAAC,CAACK,MAAM,CAAC;EACvCC,IAAI,EAAEN,CAAC,CAACK,MAAM,CAAC;IACXE,EAAE,EAAEP,CAAC,CAACE,MAAM,CAAC,CAAC,CAACM,QAAQ,CAAC,CAAC;IACzBC,IAAI,EAAET,CAAC,CAACE,MAAM,CAAC,CAAC,CAACC,GAAG,CAAC,CAAC,EAAE,kBAAkB,CAAC;IAC3CO,WAAW,EAAEV,CAAC,CAACE,MAAM,CAAC,CAAC,CAACM,QAAQ,CAAC;EACrC,CAAC;AACL,CAAC,CAAC;AAEF,OAAO,MAAMG,mBAAmB,GAAGX,CAAC,CAACK,MAAM,CAAC;EAAEJ;AAAS,CAAC,CAAC;AACzD,OAAO,MAAMW,kBAAkB,GAAGZ,CAAC,CAACK,MAAM,CAAC;EAAEJ;AAAS,CAAC,CAAC;AACxD,OAAO,MAAMY,mBAAmB,GAAGb,CAAC,CAACK,MAAM,CAAC;EAAEJ;AAAS,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"methods/tenantManager/schemas.js","sources":["../../../src/methods/tenantManager/schemas.ts"],"sourcesContent":["import { z } from \"zod\";\n\nconst tenantId = z.string().min(1, \"tenantId is required\");\n\nexport const createTenantSchema = z.object({\n    data: z.object({\n        id: z.string().optional(),\n        name: z.string().min(1, \"name is required\"),\n        description: z.string().optional()\n    })\n});\n\nexport const disableTenantSchema = z.object({ tenantId });\nexport const enableTenantSchema = z.object({ tenantId });\nexport const installTenantSchema = z.object({ tenantId });\n"],"names":["tenantId","z","createTenantSchema","disableTenantSchema","enableTenantSchema","installTenantSchema"],"mappings":";AAEA,MAAMA,WAAWC,EAAE,MAAM,GAAG,GAAG,CAAC,GAAG;AAE5B,MAAMC,qBAAqBD,EAAE,MAAM,CAAC;IACvC,MAAMA,EAAE,MAAM,CAAC;QACX,IAAIA,EAAE,MAAM,GAAG,QAAQ;QACvB,MAAMA,EAAE,MAAM,GAAG,GAAG,CAAC,GAAG;QACxB,aAAaA,EAAE,MAAM,GAAG,QAAQ;IACpC;AACJ;AAEO,MAAME,sBAAsBF,EAAE,MAAM,CAAC;IAAED,UAAAA;AAAS;AAChD,MAAMI,qBAAqBH,EAAE,MAAM,CAAC;IAAED,UAAAA;AAAS;AAC/C,MAAMK,sBAAsBJ,EAAE,MAAM,CAAC;IAAED,UAAAA;AAAS"}

package/methods/tenantManager/tenantManagerTypes.js

@@ -1,3 +0,0 @@
-export {};
-
-//# sourceMappingURL=tenantManagerTypes.js.map

package/methods/webhooks/createWebhook.d.ts

@@ -0,0 +1,12 @@
+import { Result } from "../../Result.js";
+import type { Webhook } from "./webhooksTypes.js";
+import { ApiError } from "../../errors.js";
+export interface CreateWebhookParams {
+    name: string;
+    endpointUrl: string;
+    events: string[];
+    slug?: string;
+    description?: string;
+    enabled?: boolean;
+}
+export declare const createWebhook: (config: import("../../types.js").WebinyConfig, fetchFn: typeof fetch, params: unknown) => Promise<Result<Webhook, import("../../errors.js").HttpError | ApiError | import("../../errors.js").NetworkError | import("../../errors.js").ValidationError>>;

package/methods/webhooks/createWebhook.js

@@ -0,0 +1,41 @@
+import { Result } from "../../Result.js";
+import { createMethod } from "../../utils/createMethod.js";
+import { createWebhookSchema } from "./schemas.js";
+import { executeGraphQL } from "../executeGraphQL.js";
+import { ApiError } from "../../errors.js";
+const createWebhook = createMethod(createWebhookSchema, async (config, fetchFn, params)=>{
+    const query = `
+        mutation CreateWebhook($input: CreateWebhookInput!) {
+            webhooks {
+                createWebhook(input: $input) {
+                    data {
+                        id
+                        name
+                        slug
+                        endpointUrl
+                        description
+                        enabled
+                        events
+                        signingSecret
+                        createdOn
+                        modifiedOn
+                    }
+                    error {
+                        message
+                        code
+                    }
+                }
+            }
+        }
+    `;
+    const result = await executeGraphQL(config, fetchFn, query, {
+        input: params
+    });
+    if (result.isFail()) return Result.fail(result.error);
+    const responseData = result.value;
+    if (responseData.webhooks.createWebhook.error) return Result.fail(new ApiError(responseData.webhooks.createWebhook.error.message, responseData.webhooks.createWebhook.error.code));
+    return Result.ok(responseData.webhooks.createWebhook.data);
+});
+export { createWebhook };
+
+//# sourceMappingURL=createWebhook.js.map

package/methods/webhooks/createWebhook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods/webhooks/createWebhook.js","sources":["../../../src/methods/webhooks/createWebhook.ts"],"sourcesContent":["import { Result } from \"../../Result.js\";\nimport type { Webhook } from \"./webhooksTypes.js\";\nimport { createMethod } from \"../../utils/createMethod.js\";\nimport { createWebhookSchema } from \"./schemas.js\";\nimport { executeGraphQL } from \"../executeGraphQL.js\";\nimport { ApiError } from \"../../errors.js\";\n\nexport interface CreateWebhookParams {\n    name: string;\n    endpointUrl: string;\n    events: string[];\n    slug?: string;\n    description?: string;\n    enabled?: boolean;\n}\n\nexport const createWebhook = createMethod(createWebhookSchema, async (config, fetchFn, params) => {\n    const query = `\n        mutation CreateWebhook($input: CreateWebhookInput!) {\n            webhooks {\n                createWebhook(input: $input) {\n                    data {\n                        id\n                        name\n                        slug\n                        endpointUrl\n                        description\n                        enabled\n                        events\n                        signingSecret\n                        createdOn\n                        modifiedOn\n                    }\n                    error {\n                        message\n                        code\n                    }\n                }\n            }\n        }\n    `;\n\n    const result = await executeGraphQL(config, fetchFn, query, { input: params });\n\n    if (result.isFail()) {\n        return Result.fail(result.error);\n    }\n\n    const responseData = result.value;\n\n    if (responseData.webhooks.createWebhook.error) {\n        return Result.fail(\n            new ApiError(\n                responseData.webhooks.createWebhook.error.message,\n                responseData.webhooks.createWebhook.error.code\n            )\n        );\n    }\n\n    return Result.ok(responseData.webhooks.createWebhook.data as Webhook);\n});\n"],"names":["createWebhook","createMethod","createWebhookSchema","config","fetchFn","params","query","result","executeGraphQL","Result","responseData","ApiError"],"mappings":";;;;;AAgBO,MAAMA,gBAAgBC,aAAaC,qBAAqB,OAAOC,QAAQC,SAASC;IACnF,MAAMC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;IAuBf,CAAC;IAED,MAAMC,SAAS,MAAMC,eAAeL,QAAQC,SAASE,OAAO;QAAE,OAAOD;IAAO;IAE5E,IAAIE,OAAO,MAAM,IACb,OAAOE,OAAO,IAAI,CAACF,OAAO,KAAK;IAGnC,MAAMG,eAAeH,OAAO,KAAK;IAEjC,IAAIG,aAAa,QAAQ,CAAC,aAAa,CAAC,KAAK,EACzC,OAAOD,OAAO,IAAI,CACd,IAAIE,SACAD,aAAa,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,OAAO,EACjDA,aAAa,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI;IAK1D,OAAOD,OAAO,EAAE,CAACC,aAAa,QAAQ,CAAC,aAAa,CAAC,IAAI;AAC7D"}

package/methods/webhooks/deleteWebhook.d.ts

@@ -0,0 +1,6 @@
+import { Result } from "../../Result.js";
+import { ApiError } from "../../errors.js";
+export interface DeleteWebhookParams {
+    id: string;
+}
+export declare const deleteWebhook: (config: import("../../types.js").WebinyConfig, fetchFn: typeof fetch, params: unknown) => Promise<Result<boolean, import("../../errors.js").HttpError | ApiError | import("../../errors.js").NetworkError | import("../../errors.js").ValidationError>>;

package/methods/webhooks/deleteWebhook.js

@@ -0,0 +1,30 @@
+import { Result } from "../../Result.js";
+import { createMethod } from "../../utils/createMethod.js";
+import { deleteWebhookSchema } from "./schemas.js";
+import { executeGraphQL } from "../executeGraphQL.js";
+import { ApiError } from "../../errors.js";
+const deleteWebhook = createMethod(deleteWebhookSchema, async (config, fetchFn, { id })=>{
+    const query = `
+        mutation DeleteWebhook($id: ID!) {
+            webhooks {
+                deleteWebhook(id: $id) {
+                    data
+                    error {
+                        message
+                        code
+                    }
+                }
+            }
+        }
+    `;
+    const result = await executeGraphQL(config, fetchFn, query, {
+        id
+    });
+    if (result.isFail()) return Result.fail(result.error);
+    const responseData = result.value;
+    if (responseData.webhooks.deleteWebhook.error) return Result.fail(new ApiError(responseData.webhooks.deleteWebhook.error.message, responseData.webhooks.deleteWebhook.error.code));
+    return Result.ok(responseData.webhooks.deleteWebhook.data);
+});
+export { deleteWebhook };
+
+//# sourceMappingURL=deleteWebhook.js.map

package/methods/webhooks/deleteWebhook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods/webhooks/deleteWebhook.js","sources":["../../../src/methods/webhooks/deleteWebhook.ts"],"sourcesContent":["import { Result } from \"../../Result.js\";\nimport { createMethod } from \"../../utils/createMethod.js\";\nimport { deleteWebhookSchema } from \"./schemas.js\";\nimport { executeGraphQL } from \"../executeGraphQL.js\";\nimport { ApiError } from \"../../errors.js\";\n\nexport interface DeleteWebhookParams {\n    id: string;\n}\n\nexport const deleteWebhook = createMethod(deleteWebhookSchema, async (config, fetchFn, { id }) => {\n    const query = `\n        mutation DeleteWebhook($id: ID!) {\n            webhooks {\n                deleteWebhook(id: $id) {\n                    data\n                    error {\n                        message\n                        code\n                    }\n                }\n            }\n        }\n    `;\n\n    const result = await executeGraphQL(config, fetchFn, query, { id });\n\n    if (result.isFail()) {\n        return Result.fail(result.error);\n    }\n\n    const responseData = result.value;\n\n    if (responseData.webhooks.deleteWebhook.error) {\n        return Result.fail(\n            new ApiError(\n                responseData.webhooks.deleteWebhook.error.message,\n                responseData.webhooks.deleteWebhook.error.code\n            )\n        );\n    }\n\n    return Result.ok(responseData.webhooks.deleteWebhook.data as boolean);\n});\n"],"names":["deleteWebhook","createMethod","deleteWebhookSchema","config","fetchFn","id","query","result","executeGraphQL","Result","responseData","ApiError"],"mappings":";;;;;AAUO,MAAMA,gBAAgBC,aAAaC,qBAAqB,OAAOC,QAAQC,SAAS,EAAEC,EAAE,EAAE;IACzF,MAAMC,QAAQ,CAAC;;;;;;;;;;;;IAYf,CAAC;IAED,MAAMC,SAAS,MAAMC,eAAeL,QAAQC,SAASE,OAAO;QAAED;IAAG;IAEjE,IAAIE,OAAO,MAAM,IACb,OAAOE,OAAO,IAAI,CAACF,OAAO,KAAK;IAGnC,MAAMG,eAAeH,OAAO,KAAK;IAEjC,IAAIG,aAAa,QAAQ,CAAC,aAAa,CAAC,KAAK,EACzC,OAAOD,OAAO,IAAI,CACd,IAAIE,SACAD,aAAa,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,OAAO,EACjDA,aAAa,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI;IAK1D,OAAOD,OAAO,EAAE,CAACC,aAAa,QAAQ,CAAC,aAAa,CAAC,IAAI;AAC7D"}

package/methods/webhooks/getWebhook.d.ts

@@ -0,0 +1,7 @@
+import { Result } from "../../Result.js";
+import type { Webhook } from "./webhooksTypes.js";
+import { ApiError } from "../../errors.js";
+export interface GetWebhookParams {
+    id: string;
+}
+export declare const getWebhook: (config: import("../../types.js").WebinyConfig, fetchFn: typeof fetch, params: unknown) => Promise<Result<Webhook, import("../../errors.js").HttpError | ApiError | import("../../errors.js").NetworkError | import("../../errors.js").ValidationError>>;

package/methods/webhooks/getWebhook.js

@@ -0,0 +1,41 @@
+import { Result } from "../../Result.js";
+import { createMethod } from "../../utils/createMethod.js";
+import { getWebhookSchema } from "./schemas.js";
+import { executeGraphQL } from "../executeGraphQL.js";
+import { ApiError } from "../../errors.js";
+const getWebhook = createMethod(getWebhookSchema, async (config, fetchFn, { id })=>{
+    const query = `
+        query GetWebhook($id: ID!) {
+            webhooks {
+                getWebhook(id: $id) {
+                    data {
+                        id
+                        name
+                        slug
+                        endpointUrl
+                        description
+                        enabled
+                        events
+                        signingSecret
+                        createdOn
+                        modifiedOn
+                    }
+                    error {
+                        message
+                        code
+                    }
+                }
+            }
+        }
+    `;
+    const result = await executeGraphQL(config, fetchFn, query, {
+        id
+    });
+    if (result.isFail()) return Result.fail(result.error);
+    const responseData = result.value;
+    if (responseData.webhooks.getWebhook.error) return Result.fail(new ApiError(responseData.webhooks.getWebhook.error.message, responseData.webhooks.getWebhook.error.code));
+    return Result.ok(responseData.webhooks.getWebhook.data);
+});
+export { getWebhook };
+
+//# sourceMappingURL=getWebhook.js.map

package/methods/webhooks/getWebhook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods/webhooks/getWebhook.js","sources":["../../../src/methods/webhooks/getWebhook.ts"],"sourcesContent":["import { Result } from \"../../Result.js\";\nimport type { Webhook } from \"./webhooksTypes.js\";\nimport { createMethod } from \"../../utils/createMethod.js\";\nimport { getWebhookSchema } from \"./schemas.js\";\nimport { executeGraphQL } from \"../executeGraphQL.js\";\nimport { ApiError } from \"../../errors.js\";\n\nexport interface GetWebhookParams {\n    id: string;\n}\n\nexport const getWebhook = createMethod(getWebhookSchema, async (config, fetchFn, { id }) => {\n    const query = `\n        query GetWebhook($id: ID!) {\n            webhooks {\n                getWebhook(id: $id) {\n                    data {\n                        id\n                        name\n                        slug\n                        endpointUrl\n                        description\n                        enabled\n                        events\n                        signingSecret\n                        createdOn\n                        modifiedOn\n                    }\n                    error {\n                        message\n                        code\n                    }\n                }\n            }\n        }\n    `;\n\n    const result = await executeGraphQL(config, fetchFn, query, { id });\n\n    if (result.isFail()) {\n        return Result.fail(result.error);\n    }\n\n    const responseData = result.value;\n\n    if (responseData.webhooks.getWebhook.error) {\n        return Result.fail(\n            new ApiError(\n                responseData.webhooks.getWebhook.error.message,\n                responseData.webhooks.getWebhook.error.code\n            )\n        );\n    }\n\n    return Result.ok(responseData.webhooks.getWebhook.data as Webhook);\n});\n"],"names":["getWebhook","createMethod","getWebhookSchema","config","fetchFn","id","query","result","executeGraphQL","Result","responseData","ApiError"],"mappings":";;;;;AAWO,MAAMA,aAAaC,aAAaC,kBAAkB,OAAOC,QAAQC,SAAS,EAAEC,EAAE,EAAE;IACnF,MAAMC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;IAuBf,CAAC;IAED,MAAMC,SAAS,MAAMC,eAAeL,QAAQC,SAASE,OAAO;QAAED;IAAG;IAEjE,IAAIE,OAAO,MAAM,IACb,OAAOE,OAAO,IAAI,CAACF,OAAO,KAAK;IAGnC,MAAMG,eAAeH,OAAO,KAAK;IAEjC,IAAIG,aAAa,QAAQ,CAAC,UAAU,CAAC,KAAK,EACtC,OAAOD,OAAO,IAAI,CACd,IAAIE,SACAD,aAAa,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,OAAO,EAC9CA,aAAa,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI;IAKvD,OAAOD,OAAO,EAAE,CAACC,aAAa,QAAQ,CAAC,UAAU,CAAC,IAAI;AAC1D"}

package/methods/webhooks/getWebhookDelivery.d.ts

@@ -0,0 +1,7 @@
+import { Result } from "../../Result.js";
+import type { WebhookDelivery } from "./webhooksTypes.js";
+import { ApiError } from "../../errors.js";
+export interface GetWebhookDeliveryParams {
+    id: string;
+}
+export declare const getWebhookDelivery: (config: import("../../types.js").WebinyConfig, fetchFn: typeof fetch, params: unknown) => Promise<Result<WebhookDelivery, import("../../errors.js").HttpError | ApiError | import("../../errors.js").NetworkError | import("../../errors.js").ValidationError>>;

package/methods/webhooks/getWebhookDelivery.js

@@ -0,0 +1,43 @@
+import { Result } from "../../Result.js";
+import { createMethod } from "../../utils/createMethod.js";
+import { getWebhookDeliverySchema } from "./schemas.js";
+import { executeGraphQL } from "../executeGraphQL.js";
+import { ApiError } from "../../errors.js";
+const getWebhookDelivery = createMethod(getWebhookDeliverySchema, async (config, fetchFn, { id })=>{
+    const query = `
+        query GetWebhookDelivery($id: ID!) {
+            webhooks {
+                getWebhookDelivery(id: $id) {
+                    data {
+                        id
+                        webhookId
+                        backgroundTaskId
+                        eventType
+                        status
+                        payload
+                        requestHeaders
+                        responseTime
+                        responseStatus
+                        responseBody
+                        expiresAt
+                        createdOn
+                    }
+                    error {
+                        message
+                        code
+                    }
+                }
+            }
+        }
+    `;
+    const result = await executeGraphQL(config, fetchFn, query, {
+        id
+    });
+    if (result.isFail()) return Result.fail(result.error);
+    const responseData = result.value;
+    if (responseData.webhooks.getWebhookDelivery.error) return Result.fail(new ApiError(responseData.webhooks.getWebhookDelivery.error.message, responseData.webhooks.getWebhookDelivery.error.code));
+    return Result.ok(responseData.webhooks.getWebhookDelivery.data);
+});
+export { getWebhookDelivery };
+
+//# sourceMappingURL=getWebhookDelivery.js.map

package/methods/webhooks/getWebhookDelivery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods/webhooks/getWebhookDelivery.js","sources":["../../../src/methods/webhooks/getWebhookDelivery.ts"],"sourcesContent":["import { Result } from \"../../Result.js\";\nimport type { WebhookDelivery } from \"./webhooksTypes.js\";\nimport { createMethod } from \"../../utils/createMethod.js\";\nimport { getWebhookDeliverySchema } from \"./schemas.js\";\nimport { executeGraphQL } from \"../executeGraphQL.js\";\nimport { ApiError } from \"../../errors.js\";\n\nexport interface GetWebhookDeliveryParams {\n    id: string;\n}\n\nexport const getWebhookDelivery = createMethod(\n    getWebhookDeliverySchema,\n    async (config, fetchFn, { id }) => {\n        const query = `\n        query GetWebhookDelivery($id: ID!) {\n            webhooks {\n                getWebhookDelivery(id: $id) {\n                    data {\n                        id\n                        webhookId\n                        backgroundTaskId\n                        eventType\n                        status\n                        payload\n                        requestHeaders\n                        responseTime\n                        responseStatus\n                        responseBody\n                        expiresAt\n                        createdOn\n                    }\n                    error {\n                        message\n                        code\n                    }\n                }\n            }\n        }\n    `;\n\n        const result = await executeGraphQL(config, fetchFn, query, { id });\n\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        const responseData = result.value;\n\n        if (responseData.webhooks.getWebhookDelivery.error) {\n            return Result.fail(\n                new ApiError(\n                    responseData.webhooks.getWebhookDelivery.error.message,\n                    responseData.webhooks.getWebhookDelivery.error.code\n                )\n            );\n        }\n\n        return Result.ok(responseData.webhooks.getWebhookDelivery.data as WebhookDelivery);\n    }\n);\n"],"names":["getWebhookDelivery","createMethod","getWebhookDeliverySchema","config","fetchFn","id","query","result","executeGraphQL","Result","responseData","ApiError"],"mappings":";;;;;AAWO,MAAMA,qBAAqBC,aAC9BC,0BACA,OAAOC,QAAQC,SAAS,EAAEC,EAAE,EAAE;IAC1B,MAAMC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;IAyBnB,CAAC;IAEG,MAAMC,SAAS,MAAMC,eAAeL,QAAQC,SAASE,OAAO;QAAED;IAAG;IAEjE,IAAIE,OAAO,MAAM,IACb,OAAOE,OAAO,IAAI,CAACF,OAAO,KAAK;IAGnC,MAAMG,eAAeH,OAAO,KAAK;IAEjC,IAAIG,aAAa,QAAQ,CAAC,kBAAkB,CAAC,KAAK,EAC9C,OAAOD,OAAO,IAAI,CACd,IAAIE,SACAD,aAAa,QAAQ,CAAC,kBAAkB,CAAC,KAAK,CAAC,OAAO,EACtDA,aAAa,QAAQ,CAAC,kBAAkB,CAAC,KAAK,CAAC,IAAI;IAK/D,OAAOD,OAAO,EAAE,CAACC,aAAa,QAAQ,CAAC,kBAAkB,CAAC,IAAI;AAClE"}

package/methods/webhooks/listAvailableWebhookEvents.d.ts

@@ -0,0 +1,7 @@
+import type { WebinyConfig } from "../../types.js";
+import { Result } from "../../Result.js";
+import type { HttpError } from "../../errors.js";
+import type { NetworkError } from "../../errors.js";
+import type { WebhookEvent } from "./webhooksTypes.js";
+import { ApiError } from "../../errors.js";
+export declare function listAvailableWebhookEvents(config: WebinyConfig, fetchFn: typeof fetch): Promise<Result<WebhookEvent[], HttpError | ApiError | NetworkError>>;

package/methods/webhooks/listAvailableWebhookEvents.js

@@ -0,0 +1,31 @@
+import { Result } from "../../Result.js";
+import { executeGraphQL } from "../executeGraphQL.js";
+import { ApiError } from "../../errors.js";
+async function listAvailableWebhookEvents(config, fetchFn) {
+    const query = `
+        query ListAvailableWebhookEvents {
+            webhooks {
+                listAvailableWebhookEvents {
+                    data {
+                        app
+                        entity
+                        eventName
+                        label
+                    }
+                    error {
+                        message
+                        code
+                    }
+                }
+            }
+        }
+    `;
+    const result = await executeGraphQL(config, fetchFn, query, {});
+    if (result.isFail()) return Result.fail(result.error);
+    const responseData = result.value;
+    if (responseData.webhooks.listAvailableWebhookEvents.error) return Result.fail(new ApiError(responseData.webhooks.listAvailableWebhookEvents.error.message, responseData.webhooks.listAvailableWebhookEvents.error.code));
+    return Result.ok(responseData.webhooks.listAvailableWebhookEvents.data);
+}
+export { listAvailableWebhookEvents };
+
+//# sourceMappingURL=listAvailableWebhookEvents.js.map

package/methods/webhooks/listAvailableWebhookEvents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods/webhooks/listAvailableWebhookEvents.js","sources":["../../../src/methods/webhooks/listAvailableWebhookEvents.ts"],"sourcesContent":["import type { WebinyConfig } from \"../../types.js\";\nimport { Result } from \"../../Result.js\";\nimport type { HttpError } from \"../../errors.js\";\nimport type { NetworkError } from \"../../errors.js\";\nimport type { WebhookEvent } from \"./webhooksTypes.js\";\nimport { executeGraphQL } from \"../executeGraphQL.js\";\nimport { ApiError } from \"../../errors.js\";\n\nexport async function listAvailableWebhookEvents(\n    config: WebinyConfig,\n    fetchFn: typeof fetch\n): Promise<Result<WebhookEvent[], HttpError | ApiError | NetworkError>> {\n    const query = `\n        query ListAvailableWebhookEvents {\n            webhooks {\n                listAvailableWebhookEvents {\n                    data {\n                        app\n                        entity\n                        eventName\n                        label\n                    }\n                    error {\n                        message\n                        code\n                    }\n                }\n            }\n        }\n    `;\n\n    const result = await executeGraphQL(config, fetchFn, query, {});\n\n    if (result.isFail()) {\n        return Result.fail(result.error);\n    }\n\n    const responseData = result.value;\n\n    if (responseData.webhooks.listAvailableWebhookEvents.error) {\n        return Result.fail(\n            new ApiError(\n                responseData.webhooks.listAvailableWebhookEvents.error.message,\n                responseData.webhooks.listAvailableWebhookEvents.error.code\n            )\n        );\n    }\n\n    return Result.ok(responseData.webhooks.listAvailableWebhookEvents.data as WebhookEvent[]);\n}\n"],"names":["listAvailableWebhookEvents","config","fetchFn","query","result","executeGraphQL","Result","responseData","ApiError"],"mappings":";;;AAQO,eAAeA,2BAClBC,MAAoB,EACpBC,OAAqB;IAErB,MAAMC,QAAQ,CAAC;;;;;;;;;;;;;;;;;IAiBf,CAAC;IAED,MAAMC,SAAS,MAAMC,eAAeJ,QAAQC,SAASC,OAAO,CAAC;IAE7D,IAAIC,OAAO,MAAM,IACb,OAAOE,OAAO,IAAI,CAACF,OAAO,KAAK;IAGnC,MAAMG,eAAeH,OAAO,KAAK;IAEjC,IAAIG,aAAa,QAAQ,CAAC,0BAA0B,CAAC,KAAK,EACtD,OAAOD,OAAO,IAAI,CACd,IAAIE,SACAD,aAAa,QAAQ,CAAC,0BAA0B,CAAC,KAAK,CAAC,OAAO,EAC9DA,aAAa,QAAQ,CAAC,0BAA0B,CAAC,KAAK,CAAC,IAAI;IAKvE,OAAOD,OAAO,EAAE,CAACC,aAAa,QAAQ,CAAC,0BAA0B,CAAC,IAAI;AAC1E"}

package/methods/webhooks/listWebhookDeliveries.d.ts

@@ -0,0 +1,17 @@
+import { Result } from "../../Result.js";
+import type { WebhookDelivery } from "./webhooksTypes.js";
+import { ApiError } from "../../errors.js";
+export interface ListWebhookDeliveriesParams {
+    webhookId: string;
+    limit?: number;
+    after?: string;
+}
+export interface ListWebhookDeliveriesResult {
+    data: WebhookDelivery[];
+    meta: {
+        cursor: string | null;
+        hasMoreItems: boolean;
+        totalCount: number;
+    };
+}
+export declare const listWebhookDeliveries: (config: import("../../types.js").WebinyConfig, fetchFn: typeof fetch, params: unknown) => Promise<Result<ListWebhookDeliveriesResult, import("../../errors.js").HttpError | ApiError | import("../../errors.js").NetworkError | import("../../errors.js").ValidationError>>;

package/methods/webhooks/listWebhookDeliveries.js

@@ -0,0 +1,53 @@
+import { Result } from "../../Result.js";
+import { createMethod } from "../../utils/createMethod.js";
+import { listWebhookDeliveriesSchema } from "./schemas.js";
+import { executeGraphQL } from "../executeGraphQL.js";
+import { ApiError } from "../../errors.js";
+const listWebhookDeliveries = createMethod(listWebhookDeliveriesSchema, async (config, fetchFn, { webhookId, limit, after })=>{
+    const query = `
+        query ListWebhookDeliveries($webhookId: ID!, $limit: Int, $after: String) {
+            webhooks {
+                listWebhookDeliveries(webhookId: $webhookId, limit: $limit, after: $after) {
+                    data {
+                        id
+                        webhookId
+                        backgroundTaskId
+                        eventType
+                        status
+                        payload
+                        requestHeaders
+                        responseTime
+                        responseStatus
+                        responseBody
+                        expiresAt
+                        createdOn
+                    }
+                    meta {
+                        cursor
+                        hasMoreItems
+                        totalCount
+                    }
+                    error {
+                        message
+                        code
+                    }
+                }
+            }
+        }
+    `;
+    const result = await executeGraphQL(config, fetchFn, query, {
+        webhookId,
+        limit,
+        after
+    });
+    if (result.isFail()) return Result.fail(result.error);
+    const responseData = result.value;
+    if (responseData.webhooks.listWebhookDeliveries.error) return Result.fail(new ApiError(responseData.webhooks.listWebhookDeliveries.error.message, responseData.webhooks.listWebhookDeliveries.error.code));
+    return Result.ok({
+        data: responseData.webhooks.listWebhookDeliveries.data,
+        meta: responseData.webhooks.listWebhookDeliveries.meta
+    });
+});
+export { listWebhookDeliveries };
+
+//# sourceMappingURL=listWebhookDeliveries.js.map

package/methods/webhooks/listWebhookDeliveries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods/webhooks/listWebhookDeliveries.js","sources":["../../../src/methods/webhooks/listWebhookDeliveries.ts"],"sourcesContent":["import { Result } from \"../../Result.js\";\nimport type { WebhookDelivery } from \"./webhooksTypes.js\";\nimport { createMethod } from \"../../utils/createMethod.js\";\nimport { listWebhookDeliveriesSchema } from \"./schemas.js\";\nimport { executeGraphQL } from \"../executeGraphQL.js\";\nimport { ApiError } from \"../../errors.js\";\n\nexport interface ListWebhookDeliveriesParams {\n    webhookId: string;\n    limit?: number;\n    after?: string;\n}\n\nexport interface ListWebhookDeliveriesResult {\n    data: WebhookDelivery[];\n    meta: {\n        cursor: string | null;\n        hasMoreItems: boolean;\n        totalCount: number;\n    };\n}\n\nexport const listWebhookDeliveries = createMethod(\n    listWebhookDeliveriesSchema,\n    async (config, fetchFn, { webhookId, limit, after }) => {\n        const query = `\n        query ListWebhookDeliveries($webhookId: ID!, $limit: Int, $after: String) {\n            webhooks {\n                listWebhookDeliveries(webhookId: $webhookId, limit: $limit, after: $after) {\n                    data {\n                        id\n                        webhookId\n                        backgroundTaskId\n                        eventType\n                        status\n                        payload\n                        requestHeaders\n                        responseTime\n                        responseStatus\n                        responseBody\n                        expiresAt\n                        createdOn\n                    }\n                    meta {\n                        cursor\n                        hasMoreItems\n                        totalCount\n                    }\n                    error {\n                        message\n                        code\n                    }\n                }\n            }\n        }\n    `;\n\n        const result = await executeGraphQL(config, fetchFn, query, {\n            webhookId,\n            limit,\n            after\n        });\n\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        const responseData = result.value;\n\n        if (responseData.webhooks.listWebhookDeliveries.error) {\n            return Result.fail(\n                new ApiError(\n                    responseData.webhooks.listWebhookDeliveries.error.message,\n                    responseData.webhooks.listWebhookDeliveries.error.code\n                )\n            );\n        }\n\n        return Result.ok({\n            data: responseData.webhooks.listWebhookDeliveries.data,\n            meta: responseData.webhooks.listWebhookDeliveries.meta\n        } as ListWebhookDeliveriesResult);\n    }\n);\n"],"names":["listWebhookDeliveries","createMethod","listWebhookDeliveriesSchema","config","fetchFn","webhookId","limit","after","query","result","executeGraphQL","Result","responseData","ApiError"],"mappings":";;;;;AAsBO,MAAMA,wBAAwBC,aACjCC,6BACA,OAAOC,QAAQC,SAAS,EAAEC,SAAS,EAAEC,KAAK,EAAEC,KAAK,EAAE;IAC/C,MAAMC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA8BnB,CAAC;IAEG,MAAMC,SAAS,MAAMC,eAAeP,QAAQC,SAASI,OAAO;QACxDH;QACAC;QACAC;IACJ;IAEA,IAAIE,OAAO,MAAM,IACb,OAAOE,OAAO,IAAI,CAACF,OAAO,KAAK;IAGnC,MAAMG,eAAeH,OAAO,KAAK;IAEjC,IAAIG,aAAa,QAAQ,CAAC,qBAAqB,CAAC,KAAK,EACjD,OAAOD,OAAO,IAAI,CACd,IAAIE,SACAD,aAAa,QAAQ,CAAC,qBAAqB,CAAC,KAAK,CAAC,OAAO,EACzDA,aAAa,QAAQ,CAAC,qBAAqB,CAAC,KAAK,CAAC,IAAI;IAKlE,OAAOD,OAAO,EAAE,CAAC;QACb,MAAMC,aAAa,QAAQ,CAAC,qBAAqB,CAAC,IAAI;QACtD,MAAMA,aAAa,QAAQ,CAAC,qBAAqB,CAAC,IAAI;IAC1D;AACJ"}

package/methods/webhooks/listWebhooks.d.ts

@@ -0,0 +1,19 @@
+import { Result } from "../../Result.js";
+import type { Webhook } from "./webhooksTypes.js";
+import { ApiError } from "../../errors.js";
+export interface ListWebhooksParams {
+    where?: {
+        enabled?: boolean;
+    };
+    limit?: number;
+    after?: string;
+}
+export interface ListWebhooksResult {
+    data: Webhook[];
+    meta: {
+        cursor: string | null;
+        hasMoreItems: boolean;
+        totalCount: number;
+    };
+}
+export declare const listWebhooks: (config: import("../../types.js").WebinyConfig, fetchFn: typeof fetch, params: unknown) => Promise<Result<ListWebhooksResult, import("../../errors.js").HttpError | ApiError | import("../../errors.js").NetworkError | import("../../errors.js").ValidationError>>;

package/methods/webhooks/listWebhooks.js

@@ -0,0 +1,51 @@
+import { Result } from "../../Result.js";
+import { createMethod } from "../../utils/createMethod.js";
+import { listWebhooksSchema } from "./schemas.js";
+import { executeGraphQL } from "../executeGraphQL.js";
+import { ApiError } from "../../errors.js";
+const listWebhooks = createMethod(listWebhooksSchema, async (config, fetchFn, { where, limit, after })=>{
+    const query = `
+        query ListWebhooks($where: ListWebhooksWhereInput, $limit: Int, $after: String) {
+            webhooks {
+                listWebhooks(where: $where, limit: $limit, after: $after) {
+                    data {
+                        id
+                        name
+                        slug
+                        endpointUrl
+                        description
+                        enabled
+                        events
+                        signingSecret
+                        createdOn
+                        modifiedOn
+                    }
+                    meta {
+                        cursor
+                        hasMoreItems
+                        totalCount
+                    }
+                    error {
+                        message
+                        code
+                    }
+                }
+            }
+        }
+    `;
+    const result = await executeGraphQL(config, fetchFn, query, {
+        where,
+        limit,
+        after
+    });
+    if (result.isFail()) return Result.fail(result.error);
+    const responseData = result.value;
+    if (responseData.webhooks.listWebhooks.error) return Result.fail(new ApiError(responseData.webhooks.listWebhooks.error.message, responseData.webhooks.listWebhooks.error.code));
+    return Result.ok({
+        data: responseData.webhooks.listWebhooks.data,
+        meta: responseData.webhooks.listWebhooks.meta
+    });
+});
+export { listWebhooks };
+
+//# sourceMappingURL=listWebhooks.js.map

package/methods/webhooks/listWebhooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods/webhooks/listWebhooks.js","sources":["../../../src/methods/webhooks/listWebhooks.ts"],"sourcesContent":["import { Result } from \"../../Result.js\";\nimport type { Webhook } from \"./webhooksTypes.js\";\nimport { createMethod } from \"../../utils/createMethod.js\";\nimport { listWebhooksSchema } from \"./schemas.js\";\nimport { executeGraphQL } from \"../executeGraphQL.js\";\nimport { ApiError } from \"../../errors.js\";\n\nexport interface ListWebhooksParams {\n    where?: {\n        enabled?: boolean;\n    };\n    limit?: number;\n    after?: string;\n}\n\nexport interface ListWebhooksResult {\n    data: Webhook[];\n    meta: {\n        cursor: string | null;\n        hasMoreItems: boolean;\n        totalCount: number;\n    };\n}\n\nexport const listWebhooks = createMethod(\n    listWebhooksSchema,\n    async (config, fetchFn, { where, limit, after }) => {\n        const query = `\n        query ListWebhooks($where: ListWebhooksWhereInput, $limit: Int, $after: String) {\n            webhooks {\n                listWebhooks(where: $where, limit: $limit, after: $after) {\n                    data {\n                        id\n                        name\n                        slug\n                        endpointUrl\n                        description\n                        enabled\n                        events\n                        signingSecret\n                        createdOn\n                        modifiedOn\n                    }\n                    meta {\n                        cursor\n                        hasMoreItems\n                        totalCount\n                    }\n                    error {\n                        message\n                        code\n                    }\n                }\n            }\n        }\n    `;\n\n        const result = await executeGraphQL(config, fetchFn, query, { where, limit, after });\n\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        const responseData = result.value;\n\n        if (responseData.webhooks.listWebhooks.error) {\n            return Result.fail(\n                new ApiError(\n                    responseData.webhooks.listWebhooks.error.message,\n                    responseData.webhooks.listWebhooks.error.code\n                )\n            );\n        }\n\n        return Result.ok({\n            data: responseData.webhooks.listWebhooks.data,\n            meta: responseData.webhooks.listWebhooks.meta\n        } as ListWebhooksResult);\n    }\n);\n"],"names":["listWebhooks","createMethod","listWebhooksSchema","config","fetchFn","where","limit","after","query","result","executeGraphQL","Result","responseData","ApiError"],"mappings":";;;;;AAwBO,MAAMA,eAAeC,aACxBC,oBACA,OAAOC,QAAQC,SAAS,EAAEC,KAAK,EAAEC,KAAK,EAAEC,KAAK,EAAE;IAC3C,MAAMC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA4BnB,CAAC;IAEG,MAAMC,SAAS,MAAMC,eAAeP,QAAQC,SAASI,OAAO;QAAEH;QAAOC;QAAOC;IAAM;IAElF,IAAIE,OAAO,MAAM,IACb,OAAOE,OAAO,IAAI,CAACF,OAAO,KAAK;IAGnC,MAAMG,eAAeH,OAAO,KAAK;IAEjC,IAAIG,aAAa,QAAQ,CAAC,YAAY,CAAC,KAAK,EACxC,OAAOD,OAAO,IAAI,CACd,IAAIE,SACAD,aAAa,QAAQ,CAAC,YAAY,CAAC,KAAK,CAAC,OAAO,EAChDA,aAAa,QAAQ,CAAC,YAAY,CAAC,KAAK,CAAC,IAAI;IAKzD,OAAOD,OAAO,EAAE,CAAC;QACb,MAAMC,aAAa,QAAQ,CAAC,YAAY,CAAC,IAAI;QAC7C,MAAMA,aAAa,QAAQ,CAAC,YAAY,CAAC,IAAI;IACjD;AACJ"}

package/methods/webhooks/resendWebhookDelivery.d.ts

@@ -0,0 +1,6 @@
+import { Result } from "../../Result.js";
+import { ApiError } from "../../errors.js";
+export interface ResendWebhookDeliveryParams {
+    id: string;
+}
+export declare const resendWebhookDelivery: (config: import("../../types.js").WebinyConfig, fetchFn: typeof fetch, params: unknown) => Promise<Result<boolean, import("../../errors.js").HttpError | ApiError | import("../../errors.js").NetworkError | import("../../errors.js").ValidationError>>;

package/methods/webhooks/resendWebhookDelivery.js

@@ -0,0 +1,30 @@
+import { Result } from "../../Result.js";
+import { createMethod } from "../../utils/createMethod.js";
+import { resendWebhookDeliverySchema } from "./schemas.js";
+import { executeGraphQL } from "../executeGraphQL.js";
+import { ApiError } from "../../errors.js";
+const resendWebhookDelivery = createMethod(resendWebhookDeliverySchema, async (config, fetchFn, { id })=>{
+    const query = `
+        mutation ResendWebhookDelivery($id: ID!) {
+            webhooks {
+                resendWebhookDelivery(id: $id) {
+                    data
+                    error {
+                        message
+                        code
+                    }
+                }
+            }
+        }
+    `;
+    const result = await executeGraphQL(config, fetchFn, query, {
+        id
+    });
+    if (result.isFail()) return Result.fail(result.error);
+    const responseData = result.value;
+    if (responseData.webhooks.resendWebhookDelivery.error) return Result.fail(new ApiError(responseData.webhooks.resendWebhookDelivery.error.message, responseData.webhooks.resendWebhookDelivery.error.code));
+    return Result.ok(responseData.webhooks.resendWebhookDelivery.data);
+});
+export { resendWebhookDelivery };
+
+//# sourceMappingURL=resendWebhookDelivery.js.map

package/methods/webhooks/resendWebhookDelivery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods/webhooks/resendWebhookDelivery.js","sources":["../../../src/methods/webhooks/resendWebhookDelivery.ts"],"sourcesContent":["import { Result } from \"../../Result.js\";\nimport { createMethod } from \"../../utils/createMethod.js\";\nimport { resendWebhookDeliverySchema } from \"./schemas.js\";\nimport { executeGraphQL } from \"../executeGraphQL.js\";\nimport { ApiError } from \"../../errors.js\";\n\nexport interface ResendWebhookDeliveryParams {\n    id: string;\n}\n\nexport const resendWebhookDelivery = createMethod(\n    resendWebhookDeliverySchema,\n    async (config, fetchFn, { id }) => {\n        const query = `\n        mutation ResendWebhookDelivery($id: ID!) {\n            webhooks {\n                resendWebhookDelivery(id: $id) {\n                    data\n                    error {\n                        message\n                        code\n                    }\n                }\n            }\n        }\n    `;\n\n        const result = await executeGraphQL(config, fetchFn, query, { id });\n\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        const responseData = result.value;\n\n        if (responseData.webhooks.resendWebhookDelivery.error) {\n            return Result.fail(\n                new ApiError(\n                    responseData.webhooks.resendWebhookDelivery.error.message,\n                    responseData.webhooks.resendWebhookDelivery.error.code\n                )\n            );\n        }\n\n        return Result.ok(responseData.webhooks.resendWebhookDelivery.data as boolean);\n    }\n);\n"],"names":["resendWebhookDelivery","createMethod","resendWebhookDeliverySchema","config","fetchFn","id","query","result","executeGraphQL","Result","responseData","ApiError"],"mappings":";;;;;AAUO,MAAMA,wBAAwBC,aACjCC,6BACA,OAAOC,QAAQC,SAAS,EAAEC,EAAE,EAAE;IAC1B,MAAMC,QAAQ,CAAC;;;;;;;;;;;;IAYnB,CAAC;IAEG,MAAMC,SAAS,MAAMC,eAAeL,QAAQC,SAASE,OAAO;QAAED;IAAG;IAEjE,IAAIE,OAAO,MAAM,IACb,OAAOE,OAAO,IAAI,CAACF,OAAO,KAAK;IAGnC,MAAMG,eAAeH,OAAO,KAAK;IAEjC,IAAIG,aAAa,QAAQ,CAAC,qBAAqB,CAAC,KAAK,EACjD,OAAOD,OAAO,IAAI,CACd,IAAIE,SACAD,aAAa,QAAQ,CAAC,qBAAqB,CAAC,KAAK,CAAC,OAAO,EACzDA,aAAa,QAAQ,CAAC,qBAAqB,CAAC,KAAK,CAAC,IAAI;IAKlE,OAAOD,OAAO,EAAE,CAACC,aAAa,QAAQ,CAAC,qBAAqB,CAAC,IAAI;AACrE"}