@nexeraid/identity-schemas 1.12.22-dev → 1.12.23-dev

package/webhooks/dist/nexeraid-identity-schemas-webhooks.cjs.dev.js

@@ -0,0 +1,662 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var zod = require('zod');
+var identityApi_schema = require('../../dist/identity-api.schema-8832ddec.cjs.dev.js');
+var chainalysis_schema = require('../../dist/chainalysis.schema-ab6cda47.cjs.dev.js');
+var zodToJsonSchema = require('zod-to-json-schema');
+require('nanoid');
+
+// Alert Statuses
+var AlertStatuses = ["Open", "Under Investigation", "Pending", "Closed", "Escalated"];
+var AlertStatus = zod.z["enum"](AlertStatuses);
+// Alert Types
+var AlertTypes = ["AML Screening", "IP Screening", "Email Screening", "KYC Drop-off", "Onchain Monitoring", "Fraud", "Transaction Monitoring", "Duplicate"];
+var AlertType = zod.z["enum"](AlertTypes);
+// Alert Severities
+var AlertSeverities = ["Low", "Medium", "High"];
+var AlertSeverity = zod.z["enum"](AlertSeverities);
+// Alert Categories
+var AlertCategories = ["Onboarding", "Ongoing monitoring"];
+var AlertCategory = zod.z["enum"](AlertCategories);
+var ALERT_CHART_TYPES = ["total", "new", "opened", "closed", "inProgress", "unassigned", "escalated", "overdue", "avgClosureTime", "ageOfOldest", "alertTrendsOverTime", "alertsByType", "ageOfOpenAlerts", "alertsPerOfficer", "alertsSeverity"];
+var AlertChartType = zod.z["enum"](ALERT_CHART_TYPES);
+var ALERT_TABLE_COLUMNS = ["selected", "createdAt", "overdue", "id", "severity", "type", "description", "assignedTo", "country", "status"];
+var AlertTableColumn = zod.z["enum"](ALERT_TABLE_COLUMNS);
+var UserInfoForDuplicate = zod.z.object({
+  customerId: identityApi_schema.UuidString,
+  customerInfo: zod.z.string().nullish(),
+  profilePicture: zod.z.string().nullish(),
+  idDocumentUrl: zod.z.string().nullish()
+});
+var DuplicateData = zod.z.object({
+  original: UserInfoForDuplicate,
+  duplicate: UserInfoForDuplicate
+});
+
+var AlertWebhookPayload = zod.z.object({
+  id: identityApi_schema.UuidString,
+  severity: AlertSeverity,
+  category: AlertCategory,
+  type: AlertType,
+  status: AlertStatus,
+  customerId: identityApi_schema.UuidString,
+  externalUserId: identityApi_schema.ExternalCustomerId.nullish(),
+  cmsProjectId: zod.z.string().optional(),
+  createdAt: zod.z.coerce.date(),
+  updatedAt: zod.z.coerce.date(),
+  deletedBy: zod.z.string().nullish(),
+  deletedAt: zod.z.coerce.date().nullish()
+});
+
+var CustomerWebhookPayload = zod.z.object({
+  cmsProjectId: zod.z.string(),
+  customerId: identityApi_schema.UuidString,
+  externalClientId: identityApi_schema.ExternalCustomerId.nullish(),
+  createdBy: zod.z.string(),
+  updatedBy: zod.z.string(),
+  id: zod.z.string(),
+  riskScore: identityApi_schema.RiskScoreType.nullish(),
+  type: identityApi_schema.CustomerType.nullish(),
+  onboardingLevel: identityApi_schema.CustomerOnboardingLevel.nullish(),
+  status: identityApi_schema.CustomerStatus.nullish(),
+  createdAt: zod.z.coerce.date(),
+  updatedAt: zod.z.coerce.date().nullish(),
+  reason: zod.z.string().nullish(),
+  deletedBy: zod.z.string().nullish(),
+  deletedAt: zod.z.coerce.date().nullish()
+});
+var CUSTOMER_TOPICS = ["CUSTOMER_CREATED", "CUSTOMER_UPDATED", "CUSTOMER_DELETED", "CUSTOMER_STATUS_CHANGED", "CUSTOMER_RISK_LEVEL_CHANGED", "CUSTOMER_COUNTRY"];
+var CustomerTopics = zod.z["enum"](CUSTOMER_TOPICS);
+var CustomerEvents = {
+  CUSTOMER_CREATED: zod.z.object({
+    topic: zod.z.literal("CUSTOMER_CREATED"),
+    subject: zod.z.string().describe("Customer ID"),
+    // CUSTOMER ID
+    data: CustomerWebhookPayload
+  }),
+  CUSTOMER_UPDATED: zod.z.object({
+    topic: zod.z.literal("CUSTOMER_UPDATED"),
+    subject: zod.z.string().describe("Customer ID"),
+    // CUSTOMER ID
+    data: CustomerWebhookPayload
+  }),
+  CUSTOMER_DELETED: zod.z.object({
+    topic: zod.z.literal("CUSTOMER_DELETED"),
+    subject: zod.z.string().describe("Customer ID"),
+    // CUSTOMER ID
+    data: CustomerWebhookPayload
+  }),
+  CUSTOMER_STATUS_CHANGED: zod.z.object({
+    topic: zod.z.literal("CUSTOMER_STATUS_CHANGED"),
+    subject: zod.z.string().describe("Project ID"),
+    // CMS PROJECT ID
+    data: zod.z.object({
+      cmsProjectId: zod.z.string(),
+      customerId: identityApi_schema.UuidString,
+      externalClientId: identityApi_schema.ExternalCustomerId.optional(),
+      fromStatus: identityApi_schema.CustomerStatus.optional(),
+      toStatus: identityApi_schema.CustomerStatus
+      // do we need updatedBy?
+    })
+  }),
+  CUSTOMER_RISK_LEVEL_CHANGED: zod.z.object({
+    topic: zod.z.literal("CUSTOMER_RISK_LEVEL_CHANGED"),
+    subject: zod.z.string().describe("Project ID"),
+    // CMS PROJECT ID
+    data: zod.z.object({
+      cmsProjectId: zod.z.string(),
+      customerId: identityApi_schema.UuidString,
+      externalCustomerId: identityApi_schema.ExternalCustomerId.optional(),
+      fromRiskLevel: identityApi_schema.RiskScoreType.optional(),
+      toRiskLevel: identityApi_schema.RiskScoreType,
+      riskNumber: zod.z.number().optional() // risk number is calculated based on toRiskLevel automatically when event is parsed with zod parse
+    }).transform(function (data) {
+      // assign riskNumber based on toRiskLevel (0 - 100)
+      switch (data.toRiskLevel) {
+        case "No risk":
+          data.riskNumber = 0;
+          break;
+        case "Low":
+          data.riskNumber = 25;
+          break;
+        case "Medium":
+          data.riskNumber = 50;
+          break;
+        case "High":
+          data.riskNumber = 100;
+          break;
+      }
+      return data;
+    })
+  }),
+  CUSTOMER_COUNTRY: zod.z.object({
+    topic: zod.z.literal("CUSTOMER_COUNTRY"),
+    subject: zod.z.string().describe("Project ID"),
+    // CMS PROJECT ID
+    data: zod.z.object({
+      cmsProjectId: zod.z.string(),
+      customerId: identityApi_schema.UuidString,
+      externalCustomerId: identityApi_schema.ExternalCustomerId.optional(),
+      country: identityApi_schema.ISO3CountryCode
+    })
+  })
+};
+
+var ScenarioWebhookPayloadSchema = zod.z.object({
+  customerId: zod.z.string(),
+  externalCustomerId: identityApi_schema.ExternalCustomerId.nullish(),
+  address: identityApi_schema.BlockchainAddress.nullish(),
+  result: identityApi_schema.RuleResultStatus,
+  executionId: zod.z.string(),
+  scenarios: zod.z.object({
+    scenarioId: zod.z.string(),
+    result: zod.z.object({
+      objectId: zod.z.string(),
+      result: zod.z.object({
+        // TODO maybe start using OpaChallengeQueryResponse
+        is_valid: zod.z["boolean"](),
+        reasons: zod.z.array(zod.z.unknown())
+      })
+    }).array()
+  }).array(),
+  data: identityApi_schema.GenericVerifiableCredentialSchema.array()
+});
+
+var VerificationFlowResult = zod.z.union([zod.z.object({
+  type: zod.z["enum"]([chainalysis_schema.MergedProviders["enum"].integratedScorechain, chainalysis_schema.MergedProviders["enum"].scorechain]),
+  data: chainalysis_schema.ScoringAnalysisResponse
+}), zod.z.object({
+  type: zod.z["enum"]([chainalysis_schema.MergedProviders["enum"].big]),
+  data: chainalysis_schema.BitRankVerifiedResponse
+}), zod.z.object({
+  type: zod.z["enum"]([chainalysis_schema.MergedProviders["enum"].merkleScience]),
+  data: chainalysis_schema.MerkleAddressResponse
+}), zod.z.object({
+  type: zod.z["enum"]([chainalysis_schema.MergedProviders["enum"].integratedIpqualityscore, chainalysis_schema.MergedProviders["enum"].ipQualityScore]),
+  data: chainalysis_schema.IpQualityServiceAnalysisResponse
+}), zod.z.object({
+  type: zod.z["enum"]([chainalysis_schema.MergedProviders["enum"].integratedComplyAdvantage, chainalysis_schema.MergedProviders["enum"].complyAdvantage]),
+  data: chainalysis_schema.ComplyAdvantageSearchResponse
+})]);
+var VerificationFlowChecksWebhookPayload = zod.z.object({
+  executionId: zod.z.string(),
+  customerId: zod.z.string(),
+  externalCustomerId: identityApi_schema.ExternalCustomerId.optional(),
+  address: zod.z.string().nullish(),
+  result: zod.z.array(VerificationFlowResult)
+});
+
+var WebhookEventTypes = ["send.scenario", "send.verification.flow", "customer.created", "customer.updated", "customer.deleted", "alert.created", "alert.updated", "alert.deleted"];
+var WebhookEventType = zod.z["enum"](WebhookEventTypes);
+var WebhookEventTypesForm = ["webhooks.sendScenario", "webhooks.sendVerificationFlow", "webhooks.customerCreated", "webhooks.customerUpdated", "webhooks.customerDeleted", "webhooks.alertCreated", "webhooks.alertUpdated", "webhooks.alertDeleted"];
+var WebhookEventTypeForm = zod.z["enum"](WebhookEventTypesForm);
+var AttemptsStatus = {
+  Success: 0,
+  Pending: 1,
+  Fail: 2,
+  Sending: 3
+};
+var _ref = Object.keys(AttemptsStatus),
+  _ref2 = identityApi_schema._toArray(_ref),
+  firstKey = _ref2[0],
+  othersKeys = _ref2.slice(1);
+var AttemptsStatusKeys = [firstKey].concat(identityApi_schema._toConsumableArray(othersKeys));
+var AttemptsStatusKey = zod.z["enum"](AttemptsStatusKeys);
+var AttemptsStatusCodes = ["0", "100", "200", "300", "400", "500"];
+var AttemptsStatusCode = zod.z["enum"](AttemptsStatusCodes);
+/**
+ *
+ * Schemas
+ *
+ */
+var NexeraEventTypes = zod.z.union([zod.z.object({
+  name: zod.z.literal("send.scenario"),
+  description: zod.z.string(),
+  archived: zod.z["boolean"](),
+  schemas: zod.z.record(zod.z.unknown())
+}), zod.z.object({
+  name: zod.z.literal("send.verification.flow"),
+  description: zod.z.string(),
+  archived: zod.z["boolean"](),
+  schemas: zod.z.record(zod.z.unknown())
+}), zod.z.object({
+  name: zod.z.literal("customer.created"),
+  description: zod.z.string(),
+  archived: zod.z["boolean"](),
+  schemas: zod.z.record(zod.z.unknown())
+}), zod.z.object({
+  name: zod.z.literal("customer.updated"),
+  description: zod.z.string(),
+  archived: zod.z["boolean"](),
+  schemas: zod.z.record(zod.z.unknown())
+}), zod.z.object({
+  name: zod.z.literal("customer.deleted"),
+  description: zod.z.string(),
+  archived: zod.z["boolean"](),
+  schemas: zod.z.record(zod.z.unknown())
+}), zod.z.object({
+  name: zod.z.literal("alert.created"),
+  description: zod.z.string(),
+  archived: zod.z["boolean"](),
+  schemas: zod.z.record(zod.z.unknown())
+}), zod.z.object({
+  name: zod.z.literal("alert.updated"),
+  description: zod.z.string(),
+  archived: zod.z["boolean"](),
+  schemas: zod.z.record(zod.z.unknown())
+}), zod.z.object({
+  name: zod.z.literal("alert.deleted"),
+  description: zod.z.string(),
+  archived: zod.z["boolean"](),
+  schemas: zod.z.record(zod.z.unknown())
+})]);
+
+/**
+ *
+ * Payload definitions
+ *
+ */
+var SendScenarioPayload = zod.z.object({
+  eventType: zod.z.literal("send.scenario"),
+  payload: ScenarioWebhookPayloadSchema
+});
+var SendVerificationFlowPayload = zod.z.object({
+  eventType: zod.z.literal("send.verification.flow"),
+  payload: VerificationFlowChecksWebhookPayload
+});
+var CustomerCreatedPayload = zod.z.object({
+  eventType: zod.z.literal("customer.created"),
+  payload: CustomerWebhookPayload
+});
+var CustomerUpdatedPayload = zod.z.object({
+  eventType: zod.z.literal("customer.updated"),
+  payload: CustomerWebhookPayload
+});
+var CustomerDeletedPayload = zod.z.object({
+  eventType: zod.z.literal("customer.deleted"),
+  payload: CustomerWebhookPayload
+});
+var AlertCreatedPayload = zod.z.object({
+  eventType: zod.z.literal("alert.created"),
+  payload: AlertWebhookPayload
+});
+var AlertUpdatedPayload = zod.z.object({
+  eventType: zod.z.literal("alert.updated"),
+  payload: AlertWebhookPayload
+});
+var AlertDeletedPayload = zod.z.object({
+  eventType: zod.z.literal("alert.deleted"),
+  payload: AlertWebhookPayload
+});
+var AllNexeraEventTypes = zod.z.array(NexeraEventTypes);
+var NexeraSvixEnvironmentConfig = zod.z.object({
+  env: identityApi_schema.EnvironmentSchema
+});
+var EndpointHandlingForm = zod.z.object({
+  endpointURL: zod.z.string().min(1, {
+    message: "Webhook Endpoint URL is required!"
+  }).url({
+    message: "Provided URL is not valid"
+  }),
+  name: zod.z.string().min(1, {
+    message: "Webhook name is required!"
+  }),
+  webhooks: zod.z.object({
+    sendScenario: zod.z["boolean"]().optional(),
+    sendVerificationFlow: zod.z["boolean"]().optional(),
+    customerCreated: zod.z["boolean"]().optional(),
+    customerUpdated: zod.z["boolean"]().optional(),
+    customerDeleted: zod.z["boolean"]().optional(),
+    alertCreated: zod.z["boolean"]().optional(),
+    alertUpdated: zod.z["boolean"]().optional(),
+    alertDeleted: zod.z["boolean"]().optional()
+  }).optional()
+});
+var WebhookCheckboxInformation = zod.z.object({
+  name: WebhookEventTypeForm,
+  label: zod.z.string(),
+  description: zod.z.string()
+});
+var EndpointCheckboxsCollapsiblesSchema = zod.z.object({
+  title: zod.z.string(),
+  icon: zod.z.any(),
+  description: zod.z.string(),
+  webhooks: zod.z.array(WebhookCheckboxInformation)
+});
+var EndpointOut = zod.z.object({
+  disabled: zod.z["boolean"]().optional(),
+  id: zod.z.string(),
+  description: zod.z.string(),
+  url: zod.z.string(),
+  filterTypes: zod.z.array(zod.z.string()).nullish().optional(),
+  createdAt: zod.z.coerce.date(),
+  channel: zod.z.array(zod.z.string()).optional(),
+  metadata: zod.z.record(zod.z.string()),
+  rateLimit: zod.z.number().nullish().optional(),
+  // We are using the uid
+  uid: zod.z.string().nullish().optional(),
+  version: zod.z.number(),
+  updatedAt: zod.z.coerce.date()
+});
+var MessageDataOut = zod.z.object({
+  id: zod.z.string(),
+  eventType: WebhookEventType,
+  timestamp: zod.z.coerce.date(),
+  payload: zod.z.union([SendScenarioPayload, SendVerificationFlowPayload, CustomerCreatedPayload, CustomerUpdatedPayload, CustomerDeletedPayload, AlertCreatedPayload, AlertUpdatedPayload, AlertDeletedPayload])
+});
+var AttemptDataOut = zod.z.object({
+  id: zod.z.string(),
+  url: zod.z.string(),
+  responseStatusCode: zod.z.number(),
+  status: zod.z.number(),
+  triggerType: zod.z.coerce.string(),
+  msgId: zod.z.string(),
+  endpointId: zod.z.string(),
+  timestamp: zod.z.coerce.date()
+});
+var MessageDataOutExtended = MessageDataOut.extend({
+  status: zod.z.number(),
+  url: zod.z.string(),
+  attempts: zod.z.array(AttemptDataOut)
+});
+var EventType = zod.z.object({
+  archived: zod.z["boolean"]().optional(),
+  createdAt: zod.z.coerce.date(),
+  description: zod.z.string(),
+  featureFlag: zod.z.string().optional(),
+  name: zod.z.string(),
+  schemas: zod.z.record(zod.z.unknown()).optional(),
+  updatedAt: zod.z.coerce.date()
+});
+var ListEventTypeOutput = zod.z.object({
+  data: zod.z.array(EventType),
+  done: zod.z["boolean"](),
+  iterator: zod.z.string().optional(),
+  prevIterator: zod.z.string().optional()
+});
+var CreateEndpointInput = zod.z.object({
+  projectId: zod.z.string(),
+  name: zod.z.string(),
+  eventTypes: zod.z.array(WebhookEventType),
+  url: zod.z.string()
+});
+var CreateEndpointOutput = EndpointOut.optional();
+var ListEndpointsInput = zod.z.object({
+  projectId: zod.z.string()
+});
+var ListResponseEndpointOut = zod.z.object({
+  endpoints: zod.z.array(EndpointOut)
+});
+var UpdateEndpointInput = zod.z.object({
+  projectId: zod.z.string(),
+  endpointId: zod.z.string(),
+  url: zod.z.string(),
+  name: zod.z.string(),
+  eventTypes: zod.z.array(WebhookEventType).optional(),
+  disabled: zod.z["boolean"]().optional()
+});
+var UpdateEndpointOutput = EndpointOut.optional();
+var DeleteEndpointInput = zod.z.object({
+  projectId: zod.z.string(),
+  endpointId: zod.z.string()
+});
+var DeleteEndpointOutput = zod.z["boolean"]();
+var GetEndpointSecretInput = zod.z.object({
+  projectId: zod.z.string(),
+  endpointId: zod.z.string()
+});
+var GetEndpointSecretOutput = zod.z.object({
+  key: zod.z.string()
+}).optional();
+
+/**
+ *
+ * Send Messages Types
+ *
+ */
+var SendMessageForSendScenarioInput = zod.z.object({
+  projectId: zod.z.string(),
+  payload: SendScenarioPayload
+});
+var SendMessageForSendVerificationFlowInput = zod.z.object({
+  projectId: zod.z.string(),
+  payload: SendVerificationFlowPayload
+});
+var SendMessageForCustomerCreatedInput = zod.z.object({
+  projectId: zod.z.string(),
+  payload: CustomerCreatedPayload
+});
+var SendMessageForCustomerUpdatedInput = zod.z.object({
+  projectId: zod.z.string(),
+  payload: CustomerUpdatedPayload
+});
+var SendMessageForCustomerDeletedInput = zod.z.object({
+  projectId: zod.z.string(),
+  payload: CustomerDeletedPayload
+});
+var SendMessageForAlertCreatedInput = zod.z.object({
+  projectId: zod.z.string(),
+  payload: AlertCreatedPayload
+});
+var SendMessageForAlertUpdatedInput = zod.z.object({
+  projectId: zod.z.string(),
+  payload: AlertUpdatedPayload
+});
+var SendMessageForAlertDeletedInput = zod.z.object({
+  projectId: zod.z.string(),
+  payload: AlertDeletedPayload
+});
+
+/**
+ *
+ *
+ *
+ */
+var ListMessagesInput = zod.z.object({
+  projectId: zod.z.string(),
+  eventType: WebhookEventType.optional()
+});
+var GetMessagesInput = zod.z.object({
+  projectId: zod.z.string(),
+  messageId: zod.z.string()
+});
+var ListMessagesOutput = zod.z.object({
+  messages: zod.z.array(MessageDataOut)
+});
+var ListAttemptsByMessageInput = zod.z.object({
+  projectId: zod.z.string(),
+  messageId: zod.z.string()
+});
+var ListAttemptsByEndpointInput = zod.z.object({
+  projectId: zod.z.string(),
+  endpointId: zod.z.string(),
+  eventType: WebhookEventType.optional(),
+  status: AttemptsStatusKey.optional(),
+  statusCode: AttemptsStatusCode.optional()
+});
+var ListAttemptsByMessageOutput = zod.z.object({
+  attempts: zod.z.array(AttemptDataOut)
+});
+var ConnectionHandlingWorkspaceInput = zod.z.object({
+  projectId: zod.z.string()
+});
+var ConnectionHandlingWorkspaceOutput = zod.z["boolean"]();
+var SendExampleMessageInput = zod.z.object({
+  projectId: zod.z.string(),
+  endpointId: zod.z.string(),
+  eventType: WebhookEventType
+});
+var ResendWebhookInput = zod.z.object({
+  projectId: zod.z.string(),
+  endpointId: zod.z.string(),
+  messageId: zod.z.string()
+});
+
+/**
+ *
+ * Types
+ *
+ */
+
+/**
+ *
+ * Send Messages Types
+ *
+ */
+
+/**
+ *
+ *
+ *
+ */
+
+/**
+ *
+ * Payload types
+ *
+ */
+
+/**
+ *
+ * Constants definitions
+ *
+ */
+var NexeraWebhookEvents = [{
+  name: "send.scenario",
+  description: "Send Scenario Webhook",
+  archived: false,
+  schemas: {
+    1: zodToJsonSchema.zodToJsonSchema(SendScenarioPayload)
+  }
+}, {
+  name: "send.verification.flow",
+  description: "Send Verification Flow Webhook",
+  archived: false,
+  schemas: {
+    1: zodToJsonSchema.zodToJsonSchema(SendVerificationFlowPayload)
+  }
+}, {
+  name: "customer.created",
+  description: "Customer Created Webhook",
+  archived: false,
+  schemas: {
+    1: zodToJsonSchema.zodToJsonSchema(CustomerCreatedPayload)
+  }
+}, {
+  name: "customer.updated",
+  description: "Customer Updated Webhook",
+  archived: false,
+  schemas: {
+    1: zodToJsonSchema.zodToJsonSchema(CustomerUpdatedPayload)
+  }
+}, {
+  name: "customer.deleted",
+  description: "Customer Deleted Webhook",
+  archived: false,
+  schemas: {
+    1: zodToJsonSchema.zodToJsonSchema(CustomerDeletedPayload)
+  }
+}, {
+  name: "alert.created",
+  description: "Alert Created Webhook",
+  archived: false,
+  schemas: {
+    1: zodToJsonSchema.zodToJsonSchema(AlertCreatedPayload)
+  }
+}, {
+  name: "alert.updated",
+  description: "Alert Updated Webhook",
+  archived: false,
+  schemas: {
+    1: zodToJsonSchema.zodToJsonSchema(AlertUpdatedPayload)
+  }
+}, {
+  name: "alert.deleted",
+  description: "Alert Deleted Webhook",
+  archived: false,
+  schemas: {
+    1: zodToJsonSchema.zodToJsonSchema(AlertDeletedPayload)
+  }
+}];
+
+exports.ALERT_CHART_TYPES = ALERT_CHART_TYPES;
+exports.ALERT_TABLE_COLUMNS = ALERT_TABLE_COLUMNS;
+exports.AlertCategories = AlertCategories;
+exports.AlertCategory = AlertCategory;
+exports.AlertChartType = AlertChartType;
+exports.AlertCreatedPayload = AlertCreatedPayload;
+exports.AlertDeletedPayload = AlertDeletedPayload;
+exports.AlertSeverities = AlertSeverities;
+exports.AlertSeverity = AlertSeverity;
+exports.AlertStatus = AlertStatus;
+exports.AlertStatuses = AlertStatuses;
+exports.AlertTableColumn = AlertTableColumn;
+exports.AlertType = AlertType;
+exports.AlertTypes = AlertTypes;
+exports.AlertUpdatedPayload = AlertUpdatedPayload;
+exports.AlertWebhookPayload = AlertWebhookPayload;
+exports.AllNexeraEventTypes = AllNexeraEventTypes;
+exports.AttemptDataOut = AttemptDataOut;
+exports.AttemptsStatus = AttemptsStatus;
+exports.AttemptsStatusCode = AttemptsStatusCode;
+exports.AttemptsStatusCodes = AttemptsStatusCodes;
+exports.AttemptsStatusKey = AttemptsStatusKey;
+exports.AttemptsStatusKeys = AttemptsStatusKeys;
+exports.CUSTOMER_TOPICS = CUSTOMER_TOPICS;
+exports.ConnectionHandlingWorkspaceInput = ConnectionHandlingWorkspaceInput;
+exports.ConnectionHandlingWorkspaceOutput = ConnectionHandlingWorkspaceOutput;
+exports.CreateEndpointInput = CreateEndpointInput;
+exports.CreateEndpointOutput = CreateEndpointOutput;
+exports.CustomerCreatedPayload = CustomerCreatedPayload;
+exports.CustomerDeletedPayload = CustomerDeletedPayload;
+exports.CustomerEvents = CustomerEvents;
+exports.CustomerTopics = CustomerTopics;
+exports.CustomerUpdatedPayload = CustomerUpdatedPayload;
+exports.CustomerWebhookPayload = CustomerWebhookPayload;
+exports.DeleteEndpointInput = DeleteEndpointInput;
+exports.DeleteEndpointOutput = DeleteEndpointOutput;
+exports.DuplicateData = DuplicateData;
+exports.EndpointCheckboxsCollapsiblesSchema = EndpointCheckboxsCollapsiblesSchema;
+exports.EndpointHandlingForm = EndpointHandlingForm;
+exports.EndpointOut = EndpointOut;
+exports.EventType = EventType;
+exports.GetEndpointSecretInput = GetEndpointSecretInput;
+exports.GetEndpointSecretOutput = GetEndpointSecretOutput;
+exports.GetMessagesInput = GetMessagesInput;
+exports.ListAttemptsByEndpointInput = ListAttemptsByEndpointInput;
+exports.ListAttemptsByMessageInput = ListAttemptsByMessageInput;
+exports.ListAttemptsByMessageOutput = ListAttemptsByMessageOutput;
+exports.ListEndpointsInput = ListEndpointsInput;
+exports.ListEventTypeOutput = ListEventTypeOutput;
+exports.ListMessagesInput = ListMessagesInput;
+exports.ListMessagesOutput = ListMessagesOutput;
+exports.ListResponseEndpointOut = ListResponseEndpointOut;
+exports.MessageDataOut = MessageDataOut;
+exports.MessageDataOutExtended = MessageDataOutExtended;
+exports.NexeraSvixEnvironmentConfig = NexeraSvixEnvironmentConfig;
+exports.NexeraWebhookEvents = NexeraWebhookEvents;
+exports.ResendWebhookInput = ResendWebhookInput;
+exports.ScenarioWebhookPayloadSchema = ScenarioWebhookPayloadSchema;
+exports.SendExampleMessageInput = SendExampleMessageInput;
+exports.SendMessageForAlertCreatedInput = SendMessageForAlertCreatedInput;
+exports.SendMessageForAlertDeletedInput = SendMessageForAlertDeletedInput;
+exports.SendMessageForAlertUpdatedInput = SendMessageForAlertUpdatedInput;
+exports.SendMessageForCustomerCreatedInput = SendMessageForCustomerCreatedInput;
+exports.SendMessageForCustomerDeletedInput = SendMessageForCustomerDeletedInput;
+exports.SendMessageForCustomerUpdatedInput = SendMessageForCustomerUpdatedInput;
+exports.SendMessageForSendScenarioInput = SendMessageForSendScenarioInput;
+exports.SendMessageForSendVerificationFlowInput = SendMessageForSendVerificationFlowInput;
+exports.SendScenarioPayload = SendScenarioPayload;
+exports.SendVerificationFlowPayload = SendVerificationFlowPayload;
+exports.UpdateEndpointInput = UpdateEndpointInput;
+exports.UpdateEndpointOutput = UpdateEndpointOutput;
+exports.UserInfoForDuplicate = UserInfoForDuplicate;
+exports.VerificationFlowChecksWebhookPayload = VerificationFlowChecksWebhookPayload;
+exports.VerificationFlowResult = VerificationFlowResult;
+exports.WebhookCheckboxInformation = WebhookCheckboxInformation;
+exports.WebhookEventType = WebhookEventType;
+exports.WebhookEventTypeForm = WebhookEventTypeForm;
+exports.WebhookEventTypes = WebhookEventTypes;
+exports.WebhookEventTypesForm = WebhookEventTypesForm;

package/webhooks/dist/nexeraid-identity-schemas-webhooks.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./nexeraid-identity-schemas-webhooks.cjs.prod.js");
+} else {
+  module.exports = require("./nexeraid-identity-schemas-webhooks.cjs.dev.js");
+}