@webiny/sdk 6.4.0-beta.0 → 6.4.0-beta.2

package/WebhooksSdk.d.ts

@@ -0,0 +1,35 @@
+import type { WebinyConfig } from "./types.js";
+import type { HttpError } from "./errors.js";
+import type { ApiError } from "./errors.js";
+import type { NetworkError } from "./errors.js";
+import type { ValidationError } from "./errors.js";
+import type { Result } from "./Result.js";
+import type { Webhook } from "./methods/webhooks/webhooksTypes.js";
+import type { WebhookDelivery } from "./methods/webhooks/webhooksTypes.js";
+import type { WebhookEvent } from "./methods/webhooks/webhooksTypes.js";
+import type { GetWebhookParams } from "./methods/webhooks/getWebhook.js";
+import type { ListWebhooksParams } from "./methods/webhooks/listWebhooks.js";
+import type { ListWebhooksResult } from "./methods/webhooks/listWebhooks.js";
+import type { CreateWebhookParams } from "./methods/webhooks/createWebhook.js";
+import type { UpdateWebhookParams } from "./methods/webhooks/updateWebhook.js";
+import type { DeleteWebhookParams } from "./methods/webhooks/deleteWebhook.js";
+import type { GetWebhookDeliveryParams } from "./methods/webhooks/getWebhookDelivery.js";
+import type { ListWebhookDeliveriesParams } from "./methods/webhooks/listWebhookDeliveries.js";
+import type { ListWebhookDeliveriesResult } from "./methods/webhooks/listWebhookDeliveries.js";
+import type { ResendWebhookDeliveryParams } from "./methods/webhooks/resendWebhookDelivery.js";
+import type { TriggerWebhookParams } from "./methods/webhooks/triggerWebhook.js";
+export declare class WebhooksSdk {
+    private readonly config;
+    private readonly fetchFn;
+    constructor(config: WebinyConfig);
+    getWebhook(params: GetWebhookParams): Promise<Result<Webhook, HttpError | ApiError | NetworkError | ValidationError>>;
+    listWebhooks(params?: ListWebhooksParams): Promise<Result<ListWebhooksResult, HttpError | ApiError | NetworkError | ValidationError>>;
+    createWebhook(params: CreateWebhookParams): Promise<Result<Webhook, HttpError | ApiError | NetworkError | ValidationError>>;
+    updateWebhook(params: UpdateWebhookParams): Promise<Result<Webhook, HttpError | ApiError | NetworkError | ValidationError>>;
+    deleteWebhook(params: DeleteWebhookParams): Promise<Result<boolean, HttpError | ApiError | NetworkError | ValidationError>>;
+    getWebhookDelivery(params: GetWebhookDeliveryParams): Promise<Result<WebhookDelivery, HttpError | ApiError | NetworkError | ValidationError>>;
+    listWebhookDeliveries(params: ListWebhookDeliveriesParams): Promise<Result<ListWebhookDeliveriesResult, HttpError | ApiError | NetworkError | ValidationError>>;
+    resendWebhookDelivery(params: ResendWebhookDeliveryParams): Promise<Result<boolean, HttpError | ApiError | NetworkError | ValidationError>>;
+    listAvailableWebhookEvents(): Promise<Result<WebhookEvent[], HttpError | ApiError | NetworkError>>;
+    triggerWebhook(params: TriggerWebhookParams): Promise<Result<WebhookDelivery, HttpError | ApiError | NetworkError | ValidationError>>;
+}

package/WebhooksSdk.js

@@ -0,0 +1,49 @@
+import { getWebhook } from "./methods/webhooks/getWebhook.js";
+import { listWebhooks } from "./methods/webhooks/listWebhooks.js";
+import { createWebhook } from "./methods/webhooks/createWebhook.js";
+import { updateWebhook } from "./methods/webhooks/updateWebhook.js";
+import { deleteWebhook } from "./methods/webhooks/deleteWebhook.js";
+import { getWebhookDelivery } from "./methods/webhooks/getWebhookDelivery.js";
+import { listWebhookDeliveries } from "./methods/webhooks/listWebhookDeliveries.js";
+import { resendWebhookDelivery } from "./methods/webhooks/resendWebhookDelivery.js";
+import { listAvailableWebhookEvents } from "./methods/webhooks/listAvailableWebhookEvents.js";
+import { triggerWebhook } from "./methods/webhooks/triggerWebhook.js";
+class WebhooksSdk {
+    constructor(config){
+        this.config = config;
+        this.fetchFn = config.fetch || fetch;
+    }
+    async getWebhook(params) {
+        return getWebhook(this.config, this.fetchFn, params);
+    }
+    async listWebhooks(params) {
+        return listWebhooks(this.config, this.fetchFn, params ?? {});
+    }
+    async createWebhook(params) {
+        return createWebhook(this.config, this.fetchFn, params);
+    }
+    async updateWebhook(params) {
+        return updateWebhook(this.config, this.fetchFn, params);
+    }
+    async deleteWebhook(params) {
+        return deleteWebhook(this.config, this.fetchFn, params);
+    }
+    async getWebhookDelivery(params) {
+        return getWebhookDelivery(this.config, this.fetchFn, params);
+    }
+    async listWebhookDeliveries(params) {
+        return listWebhookDeliveries(this.config, this.fetchFn, params);
+    }
+    async resendWebhookDelivery(params) {
+        return resendWebhookDelivery(this.config, this.fetchFn, params);
+    }
+    async listAvailableWebhookEvents() {
+        return listAvailableWebhookEvents(this.config, this.fetchFn);
+    }
+    async triggerWebhook(params) {
+        return triggerWebhook(this.config, this.fetchFn, params);
+    }
+}
+export { WebhooksSdk };
+
+//# sourceMappingURL=WebhooksSdk.js.map

package/WebhooksSdk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebhooksSdk.js","sources":["../src/WebhooksSdk.ts"],"sourcesContent":["import type { WebinyConfig } from \"./types.js\";\nimport type { HttpError } from \"./errors.js\";\nimport type { ApiError } from \"./errors.js\";\nimport type { NetworkError } from \"./errors.js\";\nimport type { ValidationError } from \"./errors.js\";\nimport type { Result } from \"./Result.js\";\nimport type { Webhook } from \"./methods/webhooks/webhooksTypes.js\";\nimport type { WebhookDelivery } from \"./methods/webhooks/webhooksTypes.js\";\nimport type { WebhookEvent } from \"./methods/webhooks/webhooksTypes.js\";\nimport type { GetWebhookParams } from \"./methods/webhooks/getWebhook.js\";\nimport type { ListWebhooksParams } from \"./methods/webhooks/listWebhooks.js\";\nimport type { ListWebhooksResult } from \"./methods/webhooks/listWebhooks.js\";\nimport type { CreateWebhookParams } from \"./methods/webhooks/createWebhook.js\";\nimport type { UpdateWebhookParams } from \"./methods/webhooks/updateWebhook.js\";\nimport type { DeleteWebhookParams } from \"./methods/webhooks/deleteWebhook.js\";\nimport type { GetWebhookDeliveryParams } from \"./methods/webhooks/getWebhookDelivery.js\";\nimport type { ListWebhookDeliveriesParams } from \"./methods/webhooks/listWebhookDeliveries.js\";\nimport type { ListWebhookDeliveriesResult } from \"./methods/webhooks/listWebhookDeliveries.js\";\nimport type { ResendWebhookDeliveryParams } from \"./methods/webhooks/resendWebhookDelivery.js\";\nimport type { TriggerWebhookParams } from \"./methods/webhooks/triggerWebhook.js\";\nimport { getWebhook as getWebhookFn } from \"./methods/webhooks/getWebhook.js\";\nimport { listWebhooks as listWebhooksFn } from \"./methods/webhooks/listWebhooks.js\";\nimport { createWebhook as createWebhookFn } from \"./methods/webhooks/createWebhook.js\";\nimport { updateWebhook as updateWebhookFn } from \"./methods/webhooks/updateWebhook.js\";\nimport { deleteWebhook as deleteWebhookFn } from \"./methods/webhooks/deleteWebhook.js\";\nimport { getWebhookDelivery as getWebhookDeliveryFn } from \"./methods/webhooks/getWebhookDelivery.js\";\nimport { listWebhookDeliveries as listWebhookDeliveriesFn } from \"./methods/webhooks/listWebhookDeliveries.js\";\nimport { resendWebhookDelivery as resendWebhookDeliveryFn } from \"./methods/webhooks/resendWebhookDelivery.js\";\nimport { listAvailableWebhookEvents as listAvailableWebhookEventsFn } from \"./methods/webhooks/listAvailableWebhookEvents.js\";\nimport { triggerWebhook as triggerWebhookFn } from \"./methods/webhooks/triggerWebhook.js\";\n\nexport class WebhooksSdk {\n    private readonly config: WebinyConfig;\n    private readonly fetchFn: typeof fetch;\n\n    constructor(config: WebinyConfig) {\n        this.config = config;\n        this.fetchFn = config.fetch || fetch;\n    }\n\n    async getWebhook(\n        params: GetWebhookParams\n    ): Promise<Result<Webhook, HttpError | ApiError | NetworkError | ValidationError>> {\n        return getWebhookFn(this.config, this.fetchFn, params);\n    }\n\n    async listWebhooks(\n        params?: ListWebhooksParams\n    ): Promise<Result<ListWebhooksResult, HttpError | ApiError | NetworkError | ValidationError>> {\n        return listWebhooksFn(this.config, this.fetchFn, params ?? {});\n    }\n\n    async createWebhook(\n        params: CreateWebhookParams\n    ): Promise<Result<Webhook, HttpError | ApiError | NetworkError | ValidationError>> {\n        return createWebhookFn(this.config, this.fetchFn, params);\n    }\n\n    async updateWebhook(\n        params: UpdateWebhookParams\n    ): Promise<Result<Webhook, HttpError | ApiError | NetworkError | ValidationError>> {\n        return updateWebhookFn(this.config, this.fetchFn, params);\n    }\n\n    async deleteWebhook(\n        params: DeleteWebhookParams\n    ): Promise<Result<boolean, HttpError | ApiError | NetworkError | ValidationError>> {\n        return deleteWebhookFn(this.config, this.fetchFn, params);\n    }\n\n    async getWebhookDelivery(\n        params: GetWebhookDeliveryParams\n    ): Promise<Result<WebhookDelivery, HttpError | ApiError | NetworkError | ValidationError>> {\n        return getWebhookDeliveryFn(this.config, this.fetchFn, params);\n    }\n\n    async listWebhookDeliveries(\n        params: ListWebhookDeliveriesParams\n    ): Promise<\n        Result<ListWebhookDeliveriesResult, HttpError | ApiError | NetworkError | ValidationError>\n    > {\n        return listWebhookDeliveriesFn(this.config, this.fetchFn, params);\n    }\n\n    async resendWebhookDelivery(\n        params: ResendWebhookDeliveryParams\n    ): Promise<Result<boolean, HttpError | ApiError | NetworkError | ValidationError>> {\n        return resendWebhookDeliveryFn(this.config, this.fetchFn, params);\n    }\n\n    async listAvailableWebhookEvents(): Promise<\n        Result<WebhookEvent[], HttpError | ApiError | NetworkError>\n    > {\n        return listAvailableWebhookEventsFn(this.config, this.fetchFn);\n    }\n\n    async triggerWebhook(\n        params: TriggerWebhookParams\n    ): Promise<Result<WebhookDelivery, HttpError | ApiError | NetworkError | ValidationError>> {\n        return triggerWebhookFn(this.config, this.fetchFn, params);\n    }\n}\n"],"names":["WebhooksSdk","config","fetch","params","getWebhookFn","listWebhooksFn","createWebhookFn","updateWebhookFn","deleteWebhookFn","getWebhookDeliveryFn","listWebhookDeliveriesFn","resendWebhookDeliveryFn","listAvailableWebhookEventsFn","triggerWebhookFn"],"mappings":";;;;;;;;;;AA+BO,MAAMA;IAIT,YAAYC,MAAoB,CAAE;QAC9B,IAAI,CAAC,MAAM,GAAGA;QACd,IAAI,CAAC,OAAO,GAAGA,OAAO,KAAK,IAAIC;IACnC;IAEA,MAAM,WACFC,MAAwB,EACuD;QAC/E,OAAOC,WAAa,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAED;IACnD;IAEA,MAAM,aACFA,MAA2B,EAC+D;QAC1F,OAAOE,aAAe,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAEF,UAAU,CAAC;IAChE;IAEA,MAAM,cACFA,MAA2B,EACoD;QAC/E,OAAOG,cAAgB,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAEH;IACtD;IAEA,MAAM,cACFA,MAA2B,EACoD;QAC/E,OAAOI,cAAgB,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAEJ;IACtD;IAEA,MAAM,cACFA,MAA2B,EACoD;QAC/E,OAAOK,cAAgB,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAEL;IACtD;IAEA,MAAM,mBACFA,MAAgC,EACuD;QACvF,OAAOM,mBAAqB,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAEN;IAC3D;IAEA,MAAM,sBACFA,MAAmC,EAGrC;QACE,OAAOO,sBAAwB,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAEP;IAC9D;IAEA,MAAM,sBACFA,MAAmC,EAC4C;QAC/E,OAAOQ,sBAAwB,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAER;IAC9D;IAEA,MAAM,6BAEJ;QACE,OAAOS,2BAA6B,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO;IACjE;IAEA,MAAM,eACFT,MAA4B,EAC2D;QACvF,OAAOU,eAAiB,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAEV;IACvD;AACJ"}

package/Webiny.d.ts

@@ -4,12 +4,14 @@ import { TenantManagerSdk } from "./TenantManagerSdk.js";
 import { FileManagerSdk } from "./FileManagerSdk.js";
 import { LanguagesSdk } from "./LanguagesSdk.js";
 import { TasksSdk } from "./TasksSdk.js";
+import { WebhooksSdk } from "./WebhooksSdk.js";
 export declare class Webiny {
     readonly cms: CmsSdk;
     readonly tenantManager: TenantManagerSdk;
     readonly fileManager: FileManagerSdk;
     readonly languages: LanguagesSdk;
     readonly tasks: TasksSdk;
+    readonly webhooks: WebhooksSdk;
     constructor(config: WebinyConfig);
 }
 export { Webiny as Sdk };

package/Webiny.js

@@ -3,6 +3,7 @@ import { TenantManagerSdk } from "./TenantManagerSdk.js";
 import { FileManagerSdk } from "./FileManagerSdk.js";
 import { LanguagesSdk } from "./LanguagesSdk.js";
 import { TasksSdk } from "./TasksSdk.js";
+import { WebhooksSdk } from "./WebhooksSdk.js";
 class Webiny {
     constructor(config){
         this.cms = new CmsSdk({
@@ -25,6 +26,10 @@ class Webiny {
             ...config,
             tenant: config.tenant || "root"
         });
+        this.webhooks = new WebhooksSdk({
+            ...config,
+            tenant: config.tenant || "root"
+        });
     }
 }
 export { Webiny as Sdk, Webiny };

package/Webiny.js.map

@@ -1 +1 @@
-{"version":3,"file":"Webiny.js","sources":["../src/Webiny.ts"],"sourcesContent":["import type { WebinyConfig } from \"./types.js\";\nimport { CmsSdk } from \"./CmsSdk.js\";\nimport { TenantManagerSdk } from \"./TenantManagerSdk.js\";\nimport { FileManagerSdk } from \"./FileManagerSdk.js\";\nimport { LanguagesSdk } from \"./LanguagesSdk.js\";\nimport { TasksSdk } from \"./TasksSdk.js\";\n\nexport class Webiny {\n    public readonly cms: CmsSdk;\n    public readonly tenantManager: TenantManagerSdk;\n    public readonly fileManager: FileManagerSdk;\n    public readonly languages: LanguagesSdk;\n    public readonly tasks: TasksSdk;\n\n    constructor(config: WebinyConfig) {\n        this.cms = new CmsSdk({\n            ...config,\n            tenant: config.tenant || \"root\"\n        });\n        this.tenantManager = new TenantManagerSdk({\n            ...config,\n            tenant: config.tenant || \"root\"\n        });\n        this.fileManager = new FileManagerSdk({\n            ...config,\n            tenant: config.tenant || \"root\"\n        });\n        this.languages = new LanguagesSdk({\n            ...config,\n            tenant: config.tenant || \"root\"\n        });\n        this.tasks = new TasksSdk({\n            ...config,\n            tenant: config.tenant || \"root\"\n        });\n    }\n}\n\n// Backward compatibility exports.\nexport { Webiny as Sdk };\nexport type { WebinyConfig as SdkConfig };\n"],"names":["Webiny","config","CmsSdk","TenantManagerSdk","FileManagerSdk","LanguagesSdk","TasksSdk"],"mappings":";;;;;AAOO,MAAMA;IAOT,YAAYC,MAAoB,CAAE;QAC9B,IAAI,CAAC,GAAG,GAAG,IAAIC,OAAO;YAClB,GAAGD,MAAM;YACT,QAAQA,OAAO,MAAM,IAAI;QAC7B;QACA,IAAI,CAAC,aAAa,GAAG,IAAIE,iBAAiB;YACtC,GAAGF,MAAM;YACT,QAAQA,OAAO,MAAM,IAAI;QAC7B;QACA,IAAI,CAAC,WAAW,GAAG,IAAIG,eAAe;YAClC,GAAGH,MAAM;YACT,QAAQA,OAAO,MAAM,IAAI;QAC7B;QACA,IAAI,CAAC,SAAS,GAAG,IAAII,aAAa;YAC9B,GAAGJ,MAAM;YACT,QAAQA,OAAO,MAAM,IAAI;QAC7B;QACA,IAAI,CAAC,KAAK,GAAG,IAAIK,SAAS;YACtB,GAAGL,MAAM;YACT,QAAQA,OAAO,MAAM,IAAI;QAC7B;IACJ;AACJ"}
+{"version":3,"file":"Webiny.js","sources":["../src/Webiny.ts"],"sourcesContent":["import type { WebinyConfig } from \"./types.js\";\nimport { CmsSdk } from \"./CmsSdk.js\";\nimport { TenantManagerSdk } from \"./TenantManagerSdk.js\";\nimport { FileManagerSdk } from \"./FileManagerSdk.js\";\nimport { LanguagesSdk } from \"./LanguagesSdk.js\";\nimport { TasksSdk } from \"./TasksSdk.js\";\nimport { WebhooksSdk } from \"./WebhooksSdk.js\";\n\nexport class Webiny {\n    public readonly cms: CmsSdk;\n    public readonly tenantManager: TenantManagerSdk;\n    public readonly fileManager: FileManagerSdk;\n    public readonly languages: LanguagesSdk;\n    public readonly tasks: TasksSdk;\n    public readonly webhooks: WebhooksSdk;\n\n    constructor(config: WebinyConfig) {\n        this.cms = new CmsSdk({\n            ...config,\n            tenant: config.tenant || \"root\"\n        });\n        this.tenantManager = new TenantManagerSdk({\n            ...config,\n            tenant: config.tenant || \"root\"\n        });\n        this.fileManager = new FileManagerSdk({\n            ...config,\n            tenant: config.tenant || \"root\"\n        });\n        this.languages = new LanguagesSdk({\n            ...config,\n            tenant: config.tenant || \"root\"\n        });\n        this.tasks = new TasksSdk({\n            ...config,\n            tenant: config.tenant || \"root\"\n        });\n        this.webhooks = new WebhooksSdk({\n            ...config,\n            tenant: config.tenant || \"root\"\n        });\n    }\n}\n\n// Backward compatibility exports.\nexport { Webiny as Sdk };\nexport type { WebinyConfig as SdkConfig };\n"],"names":["Webiny","config","CmsSdk","TenantManagerSdk","FileManagerSdk","LanguagesSdk","TasksSdk","WebhooksSdk"],"mappings":";;;;;;AAQO,MAAMA;IAQT,YAAYC,MAAoB,CAAE;QAC9B,IAAI,CAAC,GAAG,GAAG,IAAIC,OAAO;YAClB,GAAGD,MAAM;YACT,QAAQA,OAAO,MAAM,IAAI;QAC7B;QACA,IAAI,CAAC,aAAa,GAAG,IAAIE,iBAAiB;YACtC,GAAGF,MAAM;YACT,QAAQA,OAAO,MAAM,IAAI;QAC7B;QACA,IAAI,CAAC,WAAW,GAAG,IAAIG,eAAe;YAClC,GAAGH,MAAM;YACT,QAAQA,OAAO,MAAM,IAAI;QAC7B;QACA,IAAI,CAAC,SAAS,GAAG,IAAII,aAAa;YAC9B,GAAGJ,MAAM;YACT,QAAQA,OAAO,MAAM,IAAI;QAC7B;QACA,IAAI,CAAC,KAAK,GAAG,IAAIK,SAAS;YACtB,GAAGL,MAAM;YACT,QAAQA,OAAO,MAAM,IAAI;QAC7B;QACA,IAAI,CAAC,QAAQ,GAAG,IAAIM,YAAY;YAC5B,GAAGN,MAAM;YACT,QAAQA,OAAO,MAAM,IAAI;QAC7B;IACJ;AACJ"}

package/index.d.ts

@@ -4,6 +4,7 @@ export * from "./TenantManagerSdk.js";
 export * from "./FileManagerSdk.js";
 export * from "./LanguagesSdk.js";
 export * from "./TasksSdk.js";
+export * from "./WebhooksSdk.js";
 export * from "./types.js";
 export { Result } from "./Result.js";
 export { HttpError, ApiError, NetworkError, ValidationError } from "./errors.js";
@@ -37,3 +38,13 @@ export type { TaskStatus, TaskDefinition, TaskRun, TaskLog, TaskLogItem } from "
 export type { ListLogsParams } from "./methods/tasks/listLogs.js";
 export type { TriggerTaskParams } from "./methods/tasks/triggerTask.js";
 export type { AbortTaskParams } from "./methods/tasks/abortTask.js";
+export type { Webhook, WebhookDelivery, WebhookEvent } from "./methods/webhooks/webhooksTypes.js";
+export type { GetWebhookParams } from "./methods/webhooks/getWebhook.js";
+export type { ListWebhooksParams, ListWebhooksResult } from "./methods/webhooks/listWebhooks.js";
+export type { CreateWebhookParams } from "./methods/webhooks/createWebhook.js";
+export type { UpdateWebhookParams } from "./methods/webhooks/updateWebhook.js";
+export type { DeleteWebhookParams } from "./methods/webhooks/deleteWebhook.js";
+export type { GetWebhookDeliveryParams } from "./methods/webhooks/getWebhookDelivery.js";
+export type { ListWebhookDeliveriesParams, ListWebhookDeliveriesResult } from "./methods/webhooks/listWebhookDeliveries.js";
+export type { ResendWebhookDeliveryParams } from "./methods/webhooks/resendWebhookDelivery.js";
+export type { TriggerWebhookParams } from "./methods/webhooks/triggerWebhook.js";

package/index.js

@@ -4,6 +4,7 @@ export * from "./TenantManagerSdk.js";
 export * from "./FileManagerSdk.js";
 export * from "./LanguagesSdk.js";
 export * from "./TasksSdk.js";
+export * from "./WebhooksSdk.js";
 export * from "./types.js";
 export { Result } from "./Result.js";
 export { ApiError, HttpError, NetworkError, ValidationError } from "./errors.js";

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"}

package/methods/webhooks/schemas.d.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+export declare const getWebhookSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const listWebhooksSchema: z.ZodObject<{
+    where: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    after: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const createWebhookSchema: z.ZodObject<{
+    name: z.ZodString;
+    endpointUrl: z.ZodString;
+    events: z.ZodArray<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const updateWebhookSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+    endpointUrl: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    events: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const deleteWebhookSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const getWebhookDeliverySchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const listWebhookDeliveriesSchema: z.ZodObject<{
+    webhookId: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    after: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const resendWebhookDeliverySchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const triggerWebhookSchema: z.ZodObject<{
+    id: z.ZodString;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;

package/methods/webhooks/schemas.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+const id = z.string().min(1, "id is required");
+const getWebhookSchema = z.object({
+    id: id
+});
+const listWebhooksSchema = z.object({
+    where: z.object({
+        enabled: z.boolean().optional()
+    }).optional(),
+    limit: z.number().int().positive().optional(),
+    after: z.string().optional()
+});
+const createWebhookSchema = z.object({
+    name: z.string().min(1, "name is required"),
+    endpointUrl: z.string().url("endpointUrl must be a valid URL"),
+    events: z.array(z.string().min(1)).min(1, "events must contain at least one entry"),
+    slug: z.string().optional(),
+    description: z.string().optional(),
+    enabled: z.boolean().optional()
+});
+const updateWebhookSchema = z.object({
+    id: id,
+    name: z.string().min(1).optional(),
+    slug: z.string().optional(),
+    endpointUrl: z.string().url("endpointUrl must be a valid URL").optional(),
+    description: z.string().optional(),
+    enabled: z.boolean().optional(),
+    events: z.array(z.string().min(1)).optional()
+});
+const deleteWebhookSchema = z.object({
+    id: id
+});
+const getWebhookDeliverySchema = z.object({
+    id: id
+});
+const listWebhookDeliveriesSchema = z.object({
+    webhookId: z.string().min(1, "webhookId is required"),
+    limit: z.number().int().positive().optional(),
+    after: z.string().optional()
+});
+const resendWebhookDeliverySchema = z.object({
+    id: id
+});
+const triggerWebhookSchema = z.object({
+    id: id,
+    payload: z.record(z.string(), z.unknown())
+});
+export { createWebhookSchema, deleteWebhookSchema, getWebhookDeliverySchema, getWebhookSchema, listWebhookDeliveriesSchema, listWebhooksSchema, resendWebhookDeliverySchema, triggerWebhookSchema, updateWebhookSchema };
+
+//# sourceMappingURL=schemas.js.map

package/methods/webhooks/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods/webhooks/schemas.js","sources":["../../../src/methods/webhooks/schemas.ts"],"sourcesContent":["import { z } from \"zod\";\n\nconst id = z.string().min(1, \"id is required\");\n\nexport const getWebhookSchema = z.object({\n    id\n});\n\nexport const listWebhooksSchema = z.object({\n    where: z\n        .object({\n            enabled: z.boolean().optional()\n        })\n        .optional(),\n    limit: z.number().int().positive().optional(),\n    after: z.string().optional()\n});\n\nexport const createWebhookSchema = z.object({\n    name: z.string().min(1, \"name is required\"),\n    endpointUrl: z.string().url(\"endpointUrl must be a valid URL\"),\n    events: z.array(z.string().min(1)).min(1, \"events must contain at least one entry\"),\n    slug: z.string().optional(),\n    description: z.string().optional(),\n    enabled: z.boolean().optional()\n});\n\nexport const updateWebhookSchema = z.object({\n    id,\n    name: z.string().min(1).optional(),\n    slug: z.string().optional(),\n    endpointUrl: z.string().url(\"endpointUrl must be a valid URL\").optional(),\n    description: z.string().optional(),\n    enabled: z.boolean().optional(),\n    events: z.array(z.string().min(1)).optional()\n});\n\nexport const deleteWebhookSchema = z.object({\n    id\n});\n\nexport const getWebhookDeliverySchema = z.object({\n    id\n});\n\nexport const listWebhookDeliveriesSchema = z.object({\n    webhookId: z.string().min(1, \"webhookId is required\"),\n    limit: z.number().int().positive().optional(),\n    after: z.string().optional()\n});\n\nexport const resendWebhookDeliverySchema = z.object({\n    id\n});\n\nexport const triggerWebhookSchema = z.object({\n    id,\n    payload: z.record(z.string(), z.unknown())\n});\n"],"names":["id","z","getWebhookSchema","listWebhooksSchema","createWebhookSchema","updateWebhookSchema","deleteWebhookSchema","getWebhookDeliverySchema","listWebhookDeliveriesSchema","resendWebhookDeliverySchema","triggerWebhookSchema"],"mappings":";AAEA,MAAMA,KAAKC,EAAE,MAAM,GAAG,GAAG,CAAC,GAAG;AAEtB,MAAMC,mBAAmBD,EAAE,MAAM,CAAC;IACrCD,IAAAA;AACJ;AAEO,MAAMG,qBAAqBF,EAAE,MAAM,CAAC;IACvC,OAAOA,EAAAA,MACI,CAAC;QACJ,SAASA,EAAE,OAAO,GAAG,QAAQ;IACjC,GACC,QAAQ;IACb,OAAOA,EAAE,MAAM,GAAG,GAAG,GAAG,QAAQ,GAAG,QAAQ;IAC3C,OAAOA,EAAE,MAAM,GAAG,QAAQ;AAC9B;AAEO,MAAMG,sBAAsBH,EAAE,MAAM,CAAC;IACxC,MAAMA,EAAE,MAAM,GAAG,GAAG,CAAC,GAAG;IACxB,aAAaA,EAAE,MAAM,GAAG,GAAG,CAAC;IAC5B,QAAQA,EAAE,KAAK,CAACA,EAAE,MAAM,GAAG,GAAG,CAAC,IAAI,GAAG,CAAC,GAAG;IAC1C,MAAMA,EAAE,MAAM,GAAG,QAAQ;IACzB,aAAaA,EAAE,MAAM,GAAG,QAAQ;IAChC,SAASA,EAAE,OAAO,GAAG,QAAQ;AACjC;AAEO,MAAMI,sBAAsBJ,EAAE,MAAM,CAAC;IACxCD,IAAAA;IACA,MAAMC,EAAE,MAAM,GAAG,GAAG,CAAC,GAAG,QAAQ;IAChC,MAAMA,EAAE,MAAM,GAAG,QAAQ;IACzB,aAAaA,EAAE,MAAM,GAAG,GAAG,CAAC,mCAAmC,QAAQ;IACvE,aAAaA,EAAE,MAAM,GAAG,QAAQ;IAChC,SAASA,EAAE,OAAO,GAAG,QAAQ;IAC7B,QAAQA,EAAE,KAAK,CAACA,EAAE,MAAM,GAAG,GAAG,CAAC,IAAI,QAAQ;AAC/C;AAEO,MAAMK,sBAAsBL,EAAE,MAAM,CAAC;IACxCD,IAAAA;AACJ;AAEO,MAAMO,2BAA2BN,EAAE,MAAM,CAAC;IAC7CD,IAAAA;AACJ;AAEO,MAAMQ,8BAA8BP,EAAE,MAAM,CAAC;IAChD,WAAWA,EAAE,MAAM,GAAG,GAAG,CAAC,GAAG;IAC7B,OAAOA,EAAE,MAAM,GAAG,GAAG,GAAG,QAAQ,GAAG,QAAQ;IAC3C,OAAOA,EAAE,MAAM,GAAG,QAAQ;AAC9B;AAEO,MAAMQ,8BAA8BR,EAAE,MAAM,CAAC;IAChDD,IAAAA;AACJ;AAEO,MAAMU,uBAAuBT,EAAE,MAAM,CAAC;IACzCD,IAAAA;IACA,SAASC,EAAE,MAAM,CAACA,EAAE,MAAM,IAAIA,EAAE,OAAO;AAC3C"}

package/methods/webhooks/triggerWebhook.d.ts

@@ -0,0 +1,8 @@
+import { Result } from "../../Result.js";
+import type { WebhookDelivery } from "./webhooksTypes.js";
+import { ApiError } from "../../errors.js";
+export interface TriggerWebhookParams {
+    id: string;
+    payload: Record<string, unknown>;
+}
+export declare const triggerWebhook: (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/triggerWebhook.js

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

package/methods/webhooks/triggerWebhook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods/webhooks/triggerWebhook.js","sources":["../../../src/methods/webhooks/triggerWebhook.ts"],"sourcesContent":["import { Result } from \"../../Result.js\";\nimport type { WebhookDelivery } from \"./webhooksTypes.js\";\nimport { createMethod } from \"../../utils/createMethod.js\";\nimport { triggerWebhookSchema } from \"./schemas.js\";\nimport { executeGraphQL } from \"../executeGraphQL.js\";\nimport { ApiError } from \"../../errors.js\";\n\nexport interface TriggerWebhookParams {\n    id: string;\n    payload: Record<string, unknown>;\n}\n\nexport const triggerWebhook = createMethod(\n    triggerWebhookSchema,\n    async (config, fetchFn, { id, payload }) => {\n        const query = `\n        mutation TriggerWebhook($id: ID!, $payload: JSON!) {\n            webhooks {\n                triggerWebhook(id: $id, payload: $payload) {\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, payload });\n\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        const responseData = result.value;\n\n        if (responseData.webhooks.triggerWebhook.error) {\n            return Result.fail(\n                new ApiError(\n                    responseData.webhooks.triggerWebhook.error.message,\n                    responseData.webhooks.triggerWebhook.error.code\n                )\n            );\n        }\n\n        return Result.ok(responseData.webhooks.triggerWebhook.data as WebhookDelivery);\n    }\n);\n"],"names":["triggerWebhook","createMethod","triggerWebhookSchema","config","fetchFn","id","payload","query","result","executeGraphQL","Result","responseData","ApiError"],"mappings":";;;;;AAYO,MAAMA,iBAAiBC,aAC1BC,sBACA,OAAOC,QAAQC,SAAS,EAAEC,EAAE,EAAEC,OAAO,EAAE;IACnC,MAAMC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;IAyBnB,CAAC;IAEG,MAAMC,SAAS,MAAMC,eAAeN,QAAQC,SAASG,OAAO;QAAEF;QAAIC;IAAQ;IAE1E,IAAIE,OAAO,MAAM,IACb,OAAOE,OAAO,IAAI,CAACF,OAAO,KAAK;IAGnC,MAAMG,eAAeH,OAAO,KAAK;IAEjC,IAAIG,aAAa,QAAQ,CAAC,cAAc,CAAC,KAAK,EAC1C,OAAOD,OAAO,IAAI,CACd,IAAIE,SACAD,aAAa,QAAQ,CAAC,cAAc,CAAC,KAAK,CAAC,OAAO,EAClDA,aAAa,QAAQ,CAAC,cAAc,CAAC,KAAK,CAAC,IAAI;IAK3D,OAAOD,OAAO,EAAE,CAACC,aAAa,QAAQ,CAAC,cAAc,CAAC,IAAI;AAC9D"}

package/methods/webhooks/updateWebhook.d.ts

@@ -0,0 +1,13 @@
+import { Result } from "../../Result.js";
+import type { Webhook } from "./webhooksTypes.js";
+import { ApiError } from "../../errors.js";
+export interface UpdateWebhookParams {
+    id: string;
+    name?: string;
+    slug?: string;
+    endpointUrl?: string;
+    description?: string;
+    enabled?: boolean;
+    events?: string[];
+}
+export declare const updateWebhook: (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/updateWebhook.js

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

package/methods/webhooks/updateWebhook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods/webhooks/updateWebhook.js","sources":["../../../src/methods/webhooks/updateWebhook.ts"],"sourcesContent":["import { Result } from \"../../Result.js\";\nimport type { Webhook } from \"./webhooksTypes.js\";\nimport { createMethod } from \"../../utils/createMethod.js\";\nimport { updateWebhookSchema } from \"./schemas.js\";\nimport { executeGraphQL } from \"../executeGraphQL.js\";\nimport { ApiError } from \"../../errors.js\";\n\nexport interface UpdateWebhookParams {\n    id: string;\n    name?: string;\n    slug?: string;\n    endpointUrl?: string;\n    description?: string;\n    enabled?: boolean;\n    events?: string[];\n}\n\nexport const updateWebhook = createMethod(\n    updateWebhookSchema,\n    async (config, fetchFn, { id, ...input }) => {\n        const query = `\n        mutation UpdateWebhook($id: ID!, $input: UpdateWebhookInput!) {\n            webhooks {\n                updateWebhook(id: $id, 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, { id, input });\n\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        const responseData = result.value;\n\n        if (responseData.webhooks.updateWebhook.error) {\n            return Result.fail(\n                new ApiError(\n                    responseData.webhooks.updateWebhook.error.message,\n                    responseData.webhooks.updateWebhook.error.code\n                )\n            );\n        }\n\n        return Result.ok(responseData.webhooks.updateWebhook.data as Webhook);\n    }\n);\n"],"names":["updateWebhook","createMethod","updateWebhookSchema","config","fetchFn","id","input","query","result","executeGraphQL","Result","responseData","ApiError"],"mappings":";;;;;AAiBO,MAAMA,gBAAgBC,aACzBC,qBACA,OAAOC,QAAQC,SAAS,EAAEC,EAAE,EAAE,GAAGC,OAAO;IACpC,MAAMC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;IAuBnB,CAAC;IAEG,MAAMC,SAAS,MAAMC,eAAeN,QAAQC,SAASG,OAAO;QAAEF;QAAIC;IAAM;IAExE,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/webhooksTypes.d.ts

@@ -0,0 +1,32 @@
+export interface Webhook {
+    id: string;
+    name: string;
+    slug: string;
+    endpointUrl: string;
+    description: string | null;
+    enabled: boolean;
+    events: string[];
+    signingSecret: string;
+    createdOn: string | null;
+    modifiedOn: string | null;
+}
+export interface WebhookDelivery {
+    id: string;
+    webhookId: string;
+    backgroundTaskId: string | null;
+    eventType: string;
+    status: string;
+    payload: unknown;
+    requestHeaders: unknown;
+    responseTime: number | null;
+    responseStatus: number | null;
+    responseBody: string | null;
+    expiresAt: string | null;
+    createdOn: string | null;
+}
+export interface WebhookEvent {
+    app: string;
+    entity: string;
+    eventName: string;
+    label: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/sdk",
-	"version": "6.4.0-beta.0",
+	"version": "6.4.0-beta.2",
 	"type": "module",
 	"repository": {
 		"type": "git",
@@ -17,7 +17,7 @@
 	"author": "Webiny",
 	"license": "MIT",
 	"devDependencies": {
-		"@webiny/build-tools": "6.4.0-beta.0",
+		"@webiny/build-tools": "6.4.0-beta.2",
 		"typescript": "6.0.3",
 		"vitest": "4.1.6"
 	},
@@ -25,5 +25,5 @@
 		"access": "public",
 		"directory": "dist"
 	},
-	"gitHead": "a545d7529828af07d08d49c3da1bcb967483b9ce"
+	"gitHead": "872f9f50baa1ff6915a5f338216f84bf0b6dfd24"
 }