@dynamic-labs/sdk-api 0.0.308 → 0.0.310

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/sdk-api",
-  "version": "0.0.308",
+  "version": "0.0.310",
   "author": "Dynamic Labs",
   "license": "Apache-2.0",
   "publishConfig": {

package/src/apis/WalletsApi.cjs

@@ -12,6 +12,7 @@ require('../models/ChainEnum.cjs');
 require('../models/ChainalysisCheckResultEnum.cjs');
 require('../models/WalletProviderEnum.cjs');
 require('../models/EmbeddedWalletProviderEnum.cjs');
+var CreateUserEmbeddedWalletsRequest = require('../models/CreateUserEmbeddedWalletsRequest.cjs');
 var CreateWalletRequest = require('../models/CreateWalletRequest.cjs');
 require('../models/TimeUnitEnum.cjs');
 require('../models/JwtVerifiedCredentialFormatEnum.cjs');
@@ -36,6 +37,7 @@ require('../models/RoleEnum.cjs');
 require('../models/SubscriptionAdvancedScopeEnum.cjs');
 require('../models/SubscriptionFreeScopeEnum.cjs');
 require('../models/UnprocessableEntityErrorCode.cjs');
+var UserResponse = require('../models/UserResponse.cjs');
 var UserWalletsResponse = require('../models/UserWalletsResponse.cjs');
 require('../models/VisitorFilterableFieldsEnum.cjs');
 
@@ -44,6 +46,46 @@ require('../models/VisitorFilterableFieldsEnum.cjs');
  *
  */
 class WalletsApi extends runtime.BaseAPI {
+    /**
+     * Creates a new embedded wallet for a user given an email. If the email is not associated with a user, this call will also create a new user.
+     */
+    createEmbeddedWalletRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling createEmbeddedWallet.');
+            }
+            if (requestParameters.createUserEmbeddedWalletsRequest === null || requestParameters.createUserEmbeddedWalletsRequest === undefined) {
+                throw new runtime.RequiredError('createUserEmbeddedWalletsRequest', 'Required parameter requestParameters.createUserEmbeddedWalletsRequest was null or undefined when calling createEmbeddedWallet.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/environments/{environmentId}/embeddedWallets`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: CreateUserEmbeddedWalletsRequest.CreateUserEmbeddedWalletsRequestToJSON(requestParameters.createUserEmbeddedWalletsRequest),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => UserResponse.UserResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Creates a new embedded wallet for a user given an email. If the email is not associated with a user, this call will also create a new user.
+     */
+    createEmbeddedWallet(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.createEmbeddedWalletRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates a new wallet for the user
      */

package/src/apis/WalletsApi.d.ts

@@ -10,7 +10,11 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import { CreateWalletRequest, UserWalletsResponse, Wallet } from '../models';
+import { CreateUserEmbeddedWalletsRequest, CreateWalletRequest, UserResponse, UserWalletsResponse, Wallet } from '../models';
+export interface CreateEmbeddedWalletRequest {
+    environmentId: string;
+    createUserEmbeddedWalletsRequest: CreateUserEmbeddedWalletsRequest;
+}
 export interface CreateWalletOperationRequest {
     userId: string;
     createWalletRequest: CreateWalletRequest;
@@ -28,6 +32,14 @@ export interface GetWalletsByUserIdRequest {
  *
  */
 export declare class WalletsApi extends runtime.BaseAPI {
+    /**
+     * Creates a new embedded wallet for a user given an email. If the email is not associated with a user, this call will also create a new user.
+     */
+    createEmbeddedWalletRaw(requestParameters: CreateEmbeddedWalletRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<UserResponse>>;
+    /**
+     * Creates a new embedded wallet for a user given an email. If the email is not associated with a user, this call will also create a new user.
+     */
+    createEmbeddedWallet(requestParameters: CreateEmbeddedWalletRequest, initOverrides?: RequestInit): Promise<UserResponse>;
     /**
      * Creates a new wallet for the user
      */

package/src/apis/WalletsApi.js

@@ -8,6 +8,7 @@ import '../models/ChainEnum.js';
 import '../models/ChainalysisCheckResultEnum.js';
 import '../models/WalletProviderEnum.js';
 import '../models/EmbeddedWalletProviderEnum.js';
+import { CreateUserEmbeddedWalletsRequestToJSON } from '../models/CreateUserEmbeddedWalletsRequest.js';
 import { CreateWalletRequestToJSON } from '../models/CreateWalletRequest.js';
 import '../models/TimeUnitEnum.js';
 import '../models/JwtVerifiedCredentialFormatEnum.js';
@@ -32,6 +33,7 @@ import '../models/RoleEnum.js';
 import '../models/SubscriptionAdvancedScopeEnum.js';
 import '../models/SubscriptionFreeScopeEnum.js';
 import '../models/UnprocessableEntityErrorCode.js';
+import { UserResponseFromJSON } from '../models/UserResponse.js';
 import { UserWalletsResponseFromJSON } from '../models/UserWalletsResponse.js';
 import '../models/VisitorFilterableFieldsEnum.js';
 
@@ -40,6 +42,46 @@ import '../models/VisitorFilterableFieldsEnum.js';
  *
  */
 class WalletsApi extends BaseAPI {
+    /**
+     * Creates a new embedded wallet for a user given an email. If the email is not associated with a user, this call will also create a new user.
+     */
+    createEmbeddedWalletRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling createEmbeddedWallet.');
+            }
+            if (requestParameters.createUserEmbeddedWalletsRequest === null || requestParameters.createUserEmbeddedWalletsRequest === undefined) {
+                throw new RequiredError('createUserEmbeddedWalletsRequest', 'Required parameter requestParameters.createUserEmbeddedWalletsRequest was null or undefined when calling createEmbeddedWallet.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/environments/{environmentId}/embeddedWallets`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: CreateUserEmbeddedWalletsRequestToJSON(requestParameters.createUserEmbeddedWalletsRequest),
+            }, initOverrides);
+            return new JSONApiResponse(response, (jsonValue) => UserResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Creates a new embedded wallet for a user given an email. If the email is not associated with a user, this call will also create a new user.
+     */
+    createEmbeddedWallet(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.createEmbeddedWalletRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates a new wallet for the user
      */

package/src/apis/WebhooksApi.cjs

@@ -0,0 +1,281 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var runtime = require('../runtime.cjs');
+require('../models/AccessOutcomeEnum.cjs');
+require('../models/AuthModeEnum.cjs');
+require('../models/AuthenticatorTransportProtocol.cjs');
+require('../models/BillingSubscriptionPlanTypeEnum.cjs');
+require('../models/ChainEnum.cjs');
+require('../models/ChainalysisCheckResultEnum.cjs');
+require('../models/WalletProviderEnum.cjs');
+require('../models/EmbeddedWalletProviderEnum.cjs');
+require('../models/TimeUnitEnum.cjs');
+require('../models/JwtVerifiedCredentialFormatEnum.cjs');
+require('../models/ProviderEnum.cjs');
+require('../models/EnvironmentEnum.cjs');
+require('../models/SignInProviderEnum.cjs');
+require('../models/SocialSignInProviderEnum.cjs');
+require('../models/SdkViewSectionType.cjs');
+require('../models/SdkViewType.cjs');
+require('../models/UserFilterableFieldsEnum.cjs');
+require('../models/ExportFormatEnum.cjs');
+require('../models/ExportModelEnum.cjs');
+require('../models/ExportStatusEnum.cjs');
+require('../models/GateRuleType.cjs');
+require('../models/InviteStatusEnum.cjs');
+require('../models/NextViewEnum.cjs');
+require('../models/OauthResultStatus.cjs');
+require('../models/WhenToImplementEnum.cjs');
+require('../models/PublishEventsEvents.cjs');
+require('../models/RoleEnum.cjs');
+require('../models/SubscriptionAdvancedScopeEnum.cjs');
+require('../models/SubscriptionFreeScopeEnum.cjs');
+require('../models/UnprocessableEntityErrorCode.cjs');
+require('../models/VisitorFilterableFieldsEnum.cjs');
+var Webhook = require('../models/Webhook.cjs');
+var WebhookCreateRequest = require('../models/WebhookCreateRequest.cjs');
+var WebhookMessageRedeliveryResponse = require('../models/WebhookMessageRedeliveryResponse.cjs');
+var WebhookMessagesResponse = require('../models/WebhookMessagesResponse.cjs');
+var WebhookUpdateRequest = require('../models/WebhookUpdateRequest.cjs');
+var WebhooksResponse = require('../models/WebhooksResponse.cjs');
+
+/* tslint:disable */
+/**
+ *
+ */
+class WebhooksApi extends runtime.BaseAPI {
+    /**
+     * Creates a new Webhooks for the project environment
+     */
+    createWebhookRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling createWebhook.');
+            }
+            if (requestParameters.webhookCreateRequest === null || requestParameters.webhookCreateRequest === undefined) {
+                throw new runtime.RequiredError('webhookCreateRequest', 'Required parameter requestParameters.webhookCreateRequest was null or undefined when calling createWebhook.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            const response = yield this.request({
+                path: `/environments/{environmentId}/webhooks`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: WebhookCreateRequest.WebhookCreateRequestToJSON(requestParameters.webhookCreateRequest),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => Webhook.WebhookFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Creates a new Webhooks for the project environment
+     */
+    createWebhook(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.createWebhookRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Delete the Webhook for an environment
+     */
+    deleteWebhookByIdRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling deleteWebhookById.');
+            }
+            if (requestParameters.webhookId === null || requestParameters.webhookId === undefined) {
+                throw new runtime.RequiredError('webhookId', 'Required parameter requestParameters.webhookId was null or undefined when calling deleteWebhookById.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/environments/{environmentId}/webhooks/{webhookId}`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))).replace(`{${"webhookId"}}`, encodeURIComponent(String(requestParameters.webhookId))),
+                method: 'DELETE',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Delete the Webhook for an environment
+     */
+    deleteWebhookById(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.deleteWebhookByIdRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Get the Webhook for an environment
+     */
+    getWebhookRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling getWebhook.');
+            }
+            if (requestParameters.webhookId === null || requestParameters.webhookId === undefined) {
+                throw new runtime.RequiredError('webhookId', 'Required parameter requestParameters.webhookId was null or undefined when calling getWebhook.');
+            }
+            const queryParameters = {};
+            if (requestParameters.includeSecret !== undefined) {
+                queryParameters['includeSecret'] = requestParameters.includeSecret;
+            }
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/environments/{environmentId}/webhooks/{webhookId}`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))).replace(`{${"webhookId"}}`, encodeURIComponent(String(requestParameters.webhookId))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => Webhook.WebhookFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Get the Webhook for an environment
+     */
+    getWebhook(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getWebhookRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Get the Messages for an webhook
+     */
+    getWebhookMessagesRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling getWebhookMessages.');
+            }
+            if (requestParameters.webhookId === null || requestParameters.webhookId === undefined) {
+                throw new runtime.RequiredError('webhookId', 'Required parameter requestParameters.webhookId was null or undefined when calling getWebhookMessages.');
+            }
+            const queryParameters = {};
+            if (requestParameters.cursor !== undefined) {
+                queryParameters['cursor'] = requestParameters.cursor;
+            }
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/environments/{environmentId}/webhooks/{webhookId}/messages`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))).replace(`{${"webhookId"}}`, encodeURIComponent(String(requestParameters.webhookId))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => WebhookMessagesResponse.WebhookMessagesResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Get the Messages for an webhook
+     */
+    getWebhookMessages(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getWebhookMessagesRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Get the Webhooks for an environment
+     */
+    getWebhooksRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling getWebhooks.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/environments/{environmentId}/webhooks`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => WebhooksResponse.WebhooksResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Get the Webhooks for an environment
+     */
+    getWebhooks(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getWebhooksRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Redeliver message for an webhook
+     */
+    redeliverWebhookMessageRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling redeliverWebhookMessage.');
+            }
+            if (requestParameters.webhookId === null || requestParameters.webhookId === undefined) {
+                throw new runtime.RequiredError('webhookId', 'Required parameter requestParameters.webhookId was null or undefined when calling redeliverWebhookMessage.');
+            }
+            if (requestParameters.messageId === null || requestParameters.messageId === undefined) {
+                throw new runtime.RequiredError('messageId', 'Required parameter requestParameters.messageId was null or undefined when calling redeliverWebhookMessage.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/environments/{environmentId}/webhooks/{webhookId}/messages/{messageId}/redeliver`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))).replace(`{${"webhookId"}}`, encodeURIComponent(String(requestParameters.webhookId))).replace(`{${"messageId"}}`, encodeURIComponent(String(requestParameters.messageId))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => WebhookMessageRedeliveryResponse.WebhookMessageRedeliveryResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Redeliver message for an webhook
+     */
+    redeliverWebhookMessage(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.redeliverWebhookMessageRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Update the Webhook for an environment
+     */
+    updateWebhookByIdRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling updateWebhookById.');
+            }
+            if (requestParameters.webhookId === null || requestParameters.webhookId === undefined) {
+                throw new runtime.RequiredError('webhookId', 'Required parameter requestParameters.webhookId was null or undefined when calling updateWebhookById.');
+            }
+            if (requestParameters.webhookUpdateRequest === null || requestParameters.webhookUpdateRequest === undefined) {
+                throw new runtime.RequiredError('webhookUpdateRequest', 'Required parameter requestParameters.webhookUpdateRequest was null or undefined when calling updateWebhookById.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            const response = yield this.request({
+                path: `/environments/{environmentId}/webhooks/{webhookId}`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))).replace(`{${"webhookId"}}`, encodeURIComponent(String(requestParameters.webhookId))),
+                method: 'PUT',
+                headers: headerParameters,
+                query: queryParameters,
+                body: WebhookUpdateRequest.WebhookUpdateRequestToJSON(requestParameters.webhookUpdateRequest),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => Webhook.WebhookFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Update the Webhook for an environment
+     */
+    updateWebhookById(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.updateWebhookByIdRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+}
+
+exports.WebhooksApi = WebhooksApi;

package/src/apis/WebhooksApi.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Dashboard API
+ * Dashboard API documentation
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import * as runtime from '../runtime';
+import { Webhook, WebhookCreateRequest, WebhookMessageRedeliveryResponse, WebhookMessagesResponse, WebhookUpdateRequest, WebhooksResponse } from '../models';
+export interface CreateWebhookRequest {
+    environmentId: string;
+    webhookCreateRequest: WebhookCreateRequest;
+}
+export interface DeleteWebhookByIdRequest {
+    environmentId: string;
+    webhookId: string;
+}
+export interface GetWebhookRequest {
+    environmentId: string;
+    webhookId: string;
+    includeSecret?: boolean;
+}
+export interface GetWebhookMessagesRequest {
+    environmentId: string;
+    webhookId: string;
+    cursor?: string;
+}
+export interface GetWebhooksRequest {
+    environmentId: string;
+}
+export interface RedeliverWebhookMessageRequest {
+    environmentId: string;
+    webhookId: string;
+    messageId: string;
+}
+export interface UpdateWebhookByIdRequest {
+    environmentId: string;
+    webhookId: string;
+    webhookUpdateRequest: WebhookUpdateRequest;
+}
+/**
+ *
+ */
+export declare class WebhooksApi extends runtime.BaseAPI {
+    /**
+     * Creates a new Webhooks for the project environment
+     */
+    createWebhookRaw(requestParameters: CreateWebhookRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Webhook>>;
+    /**
+     * Creates a new Webhooks for the project environment
+     */
+    createWebhook(requestParameters: CreateWebhookRequest, initOverrides?: RequestInit): Promise<Webhook>;
+    /**
+     * Delete the Webhook for an environment
+     */
+    deleteWebhookByIdRaw(requestParameters: DeleteWebhookByIdRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>>;
+    /**
+     * Delete the Webhook for an environment
+     */
+    deleteWebhookById(requestParameters: DeleteWebhookByIdRequest, initOverrides?: RequestInit): Promise<void>;
+    /**
+     * Get the Webhook for an environment
+     */
+    getWebhookRaw(requestParameters: GetWebhookRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Webhook>>;
+    /**
+     * Get the Webhook for an environment
+     */
+    getWebhook(requestParameters: GetWebhookRequest, initOverrides?: RequestInit): Promise<Webhook>;
+    /**
+     * Get the Messages for an webhook
+     */
+    getWebhookMessagesRaw(requestParameters: GetWebhookMessagesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<WebhookMessagesResponse>>;
+    /**
+     * Get the Messages for an webhook
+     */
+    getWebhookMessages(requestParameters: GetWebhookMessagesRequest, initOverrides?: RequestInit): Promise<WebhookMessagesResponse>;
+    /**
+     * Get the Webhooks for an environment
+     */
+    getWebhooksRaw(requestParameters: GetWebhooksRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<WebhooksResponse>>;
+    /**
+     * Get the Webhooks for an environment
+     */
+    getWebhooks(requestParameters: GetWebhooksRequest, initOverrides?: RequestInit): Promise<WebhooksResponse>;
+    /**
+     * Redeliver message for an webhook
+     */
+    redeliverWebhookMessageRaw(requestParameters: RedeliverWebhookMessageRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<WebhookMessageRedeliveryResponse>>;
+    /**
+     * Redeliver message for an webhook
+     */
+    redeliverWebhookMessage(requestParameters: RedeliverWebhookMessageRequest, initOverrides?: RequestInit): Promise<WebhookMessageRedeliveryResponse>;
+    /**
+     * Update the Webhook for an environment
+     */
+    updateWebhookByIdRaw(requestParameters: UpdateWebhookByIdRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Webhook>>;
+    /**
+     * Update the Webhook for an environment
+     */
+    updateWebhookById(requestParameters: UpdateWebhookByIdRequest, initOverrides?: RequestInit): Promise<Webhook>;
+}