@secondlayer/shared 11.4.2 → 11.5.0

package/dist/src/schemas/index.d.ts

@@ -60,8 +60,8 @@ interface SubgraphSummary {
 	lastErrorAt?: string | null;
 	/** Last row mutation timestamp; powers per-card freshness. */
 	updatedAt?: string | null;
-	/** Number of subscriptions attached to this subgraph. */
-	subscriptionCount?: number;
+	/** Number of webhooks attached to this subgraph. */
+	webhookCount?: number;
 	createdAt: string;
 }
 interface SubgraphGapRange {
@@ -202,17 +202,17 @@ interface SubgraphAggregateResponse {
 	max?: Record<string, string | null>;
 }
 import { z as z2 } from "zod";
-declare const SUBSCRIPTION_FORMATS: readonly ["standard-webhooks", "inngest", "trigger", "cloudflare", "cloudevents", "raw"];
-declare const SUBSCRIPTION_RUNTIMES: readonly ["inngest", "trigger", "cloudflare", "node"];
-declare const SUBSCRIPTION_STATUSES: readonly ["active", "paused", "error"];
-declare const SUBSCRIPTION_FILTER_OPERATORS: readonly ["eq", "neq", "gt", "gte", "lt", "lte", "in"];
-declare const SubscriptionStatusSchema: z2.ZodType<SubscriptionStatus>;
-declare const SubscriptionFormatSchema: z2.ZodType<SubscriptionFormat>;
-declare const SubscriptionRuntimeSchema: z2.ZodType<SubscriptionRuntime>;
-declare const SubscriptionFilterPrimitiveSchema: z2.ZodType<SubscriptionFilterPrimitive>;
-declare const SubscriptionFilterOperatorSchema: z2.ZodType<SubscriptionFilterOperator>;
-declare const SubscriptionFilterClauseSchema: z2.ZodType<SubscriptionFilterClause>;
-declare const SubscriptionFilterSchema: z2.ZodType<SubscriptionFilter>;
+declare const WEBHOOK_FORMATS: readonly ["standard-webhooks", "inngest", "trigger", "cloudflare", "cloudevents", "raw"];
+declare const WEBHOOK_RUNTIMES: readonly ["inngest", "trigger", "cloudflare", "node"];
+declare const WEBHOOK_STATUSES: readonly ["active", "paused", "error"];
+declare const WEBHOOK_FILTER_OPERATORS: readonly ["eq", "neq", "gt", "gte", "lt", "lte", "in"];
+declare const WebhookStatusSchema: z2.ZodType<WebhookStatus>;
+declare const WebhookFormatSchema: z2.ZodType<WebhookFormat>;
+declare const WebhookRuntimeSchema: z2.ZodType<WebhookRuntime>;
+declare const WebhookFilterPrimitiveSchema: z2.ZodType<WebhookFilterPrimitive>;
+declare const WebhookFilterOperatorSchema: z2.ZodType<WebhookFilterOperator>;
+declare const WebhookFilterClauseSchema: z2.ZodType<WebhookFilterClause>;
+declare const WebhookFilterSchema: z2.ZodType<WebhookFilter>;
 declare const CHAIN_TRIGGER_TYPES: readonly ["stx_transfer", "stx_mint", "stx_burn", "stx_lock", "ft_transfer", "ft_mint", "ft_burn", "nft_transfer", "nft_mint", "nft_burn", "contract_call", "contract_deploy", "print_event", "sbtc_deposit", "sbtc_withdrawal_create", "sbtc_withdrawal_accept", "sbtc_withdrawal_reject", "sbtc_withdrawal_swept_confirmed"];
 /**
 * Per-type accepted filter fields for chain triggers, DERIVED from
@@ -220,19 +220,19 @@ declare const CHAIN_TRIGGER_TYPES: readonly ["stx_transfer", "stx_mint", "stx_bu
 * the validator. `{ stx_transfer: ["sender","recipient","minAmount","maxAmount"], ... }`.
 */
 declare const CHAIN_TRIGGER_FIELDS: Record<string, string[]>;
-declare const CreateSubscriptionRequestSchema: z2.ZodType<ParsedCreateSubscriptionRequest>;
-declare const UpdateSubscriptionRequestSchema: z2.ZodType<UpdateSubscriptionRequest>;
-declare const ReplaySubscriptionRequestSchema: z2.ZodType<ReplaySubscriptionRequest>;
-type SubscriptionStatus = (typeof SUBSCRIPTION_STATUSES)[number];
-/** Polymorphic subscription mode (mirrors db/types `SubscriptionKind`). */
-type SubscriptionKind = "subgraph" | "chain";
-type SubscriptionFormat = (typeof SUBSCRIPTION_FORMATS)[number];
-type SubscriptionRuntime = (typeof SUBSCRIPTION_RUNTIMES)[number];
-type SubscriptionFilterPrimitive = string | number | boolean;
-type SubscriptionFilterOperator = {
-	eq: SubscriptionFilterPrimitive
+declare const CreateWebhookRequestSchema: z2.ZodType<ParsedCreateWebhookRequest>;
+declare const UpdateWebhookRequestSchema: z2.ZodType<UpdateWebhookRequest>;
+declare const ReplayWebhookRequestSchema: z2.ZodType<ReplayWebhookRequest>;
+type WebhookStatus = (typeof WEBHOOK_STATUSES)[number];
+/** Polymorphic webhook mode (mirrors db/types `WebhookKind`). */
+type WebhookKind = "subgraph" | "chain";
+type WebhookFormat = (typeof WEBHOOK_FORMATS)[number];
+type WebhookRuntime = (typeof WEBHOOK_RUNTIMES)[number];
+type WebhookFilterPrimitive = string | number | boolean;
+type WebhookFilterOperator = {
+	eq: WebhookFilterPrimitive
 } | {
-	neq: SubscriptionFilterPrimitive
+	neq: WebhookFilterPrimitive
 } | {
 	gt: string | number
 } | {
@@ -242,10 +242,10 @@ type SubscriptionFilterOperator = {
 } | {
 	lte: string | number
 } | {
-	in: SubscriptionFilterPrimitive[]
+	in: WebhookFilterPrimitive[]
 };
-type SubscriptionFilterClause = SubscriptionFilterPrimitive | SubscriptionFilterOperator;
-type SubscriptionFilter = Record<string, SubscriptionFilterClause>;
+type WebhookFilterClause = WebhookFilterPrimitive | WebhookFilterOperator;
+type WebhookFilter = Record<string, WebhookFilterClause>;
 /** Non-negative integer amount over JSON (string for uint128 safety, or number). */
 type ChainTriggerAmount = string | number;
 interface TraitScoped {
@@ -337,63 +337,63 @@ type ChainTrigger = {
 	requestId?: number
 	sweepTxid?: string
 };
-interface CreateSubscriptionRequest {
+interface CreateWebhookRequest {
 	name: string;
 	/** Subgraph mode. */
 	subgraphName?: string;
 	tableName?: string;
-	filter?: SubscriptionFilter;
+	filter?: WebhookFilter;
 	/** Chain mode. */
 	triggers?: ChainTrigger[];
 	url: string;
-	format?: SubscriptionFormat;
-	runtime?: SubscriptionRuntime | null;
+	format?: WebhookFormat;
+	runtime?: WebhookRuntime | null;
 	authConfig?: Record<string, unknown>;
 	maxRetries?: number;
 	timeoutMs?: number;
 	concurrency?: number;
 }
-interface ParsedCreateSubscriptionRequest extends Omit<CreateSubscriptionRequest, "format"> {
-	format: SubscriptionFormat;
+interface ParsedCreateWebhookRequest extends Omit<CreateWebhookRequest, "format"> {
+	format: WebhookFormat;
 }
-interface UpdateSubscriptionRequest {
+interface UpdateWebhookRequest {
 	name?: string;
 	url?: string;
-	filter?: SubscriptionFilter;
-	format?: SubscriptionFormat;
-	runtime?: SubscriptionRuntime | null;
+	filter?: WebhookFilter;
+	format?: WebhookFormat;
+	runtime?: WebhookRuntime | null;
 	authConfig?: Record<string, unknown>;
 	maxRetries?: number;
 	timeoutMs?: number;
 	concurrency?: number;
 }
-type ParsedUpdateSubscriptionRequest = UpdateSubscriptionRequest;
-interface ReplaySubscriptionRequest {
+type ParsedUpdateWebhookRequest = UpdateWebhookRequest;
+interface ReplayWebhookRequest {
 	fromBlock: number;
 	toBlock: number;
 	force?: string;
 }
-type ParsedReplaySubscriptionRequest = ReplaySubscriptionRequest;
-interface SubscriptionSummary {
+type ParsedReplayWebhookRequest = ReplayWebhookRequest;
+interface WebhookSummary {
 	id: string;
 	name: string;
-	status: SubscriptionStatus;
-	kind: SubscriptionKind;
-	/** Null for chain subscriptions. */
+	status: WebhookStatus;
+	kind: WebhookKind;
+	/** Null for chain webhooks. */
 	subgraphName: string | null;
-	/** Null for chain subscriptions. */
+	/** Null for chain webhooks. */
 	tableName: string | null;
-	format: SubscriptionFormat;
-	runtime: SubscriptionRuntime | null;
+	format: WebhookFormat;
+	runtime: WebhookRuntime | null;
 	url: string;
 	lastDeliveryAt: string | null;
 	lastSuccessAt: string | null;
 	createdAt: string;
 	updatedAt: string;
 }
-interface SubscriptionDetail extends SubscriptionSummary {
+interface WebhookDetail extends WebhookSummary {
 	filter: Record<string, unknown>;
-	/** Chain-trigger filters (chain subscriptions only). */
+	/** Chain-trigger filters (chain webhooks only). */
 	triggers: ChainTrigger[] | null;
 	authConfig: Record<string, unknown>;
 	maxRetries: number;
@@ -403,13 +403,13 @@ interface SubscriptionDetail extends SubscriptionSummary {
 	circuitOpenedAt: string | null;
 	lastError: string | null;
 }
-interface CreateSubscriptionResponse {
-	subscription: SubscriptionDetail;
+interface CreateWebhookResponse {
+	webhook: WebhookDetail;
 	/** Plaintext signing secret — surfaced ONCE. Store it server-side. */
 	signingSecret: string;
 }
 interface RotateSecretResponse {
-	subscription: SubscriptionDetail;
+	webhook: WebhookDetail;
 	signingSecret: string;
 }
 interface DeliveryRow {
@@ -436,18 +436,18 @@ interface DeadRow {
 	failedAt: string | null;
 	createdAt: string;
 }
-interface SubscriptionSchemaColumn {
+interface WebhookSchemaColumn {
 	type?: unknown;
 }
-interface SubscriptionSchemaTable {
-	columns: Record<string, SubscriptionSchemaColumn>;
+interface WebhookSchemaTable {
+	columns: Record<string, WebhookSchemaColumn>;
 }
-type SubscriptionSchemaTables = Record<string, SubscriptionSchemaTable>;
-declare function formatSubscriptionSchemaErrors(error: z2.ZodError): string[];
-declare function validateSubscriptionFilterForTable(input: {
+type WebhookSchemaTables = Record<string, WebhookSchemaTable>;
+declare function formatWebhookSchemaErrors(error: z2.ZodError): string[];
+declare function validateWebhookFilterForTable(input: {
 	subgraphName?: string
 	tableName: string
 	filter?: unknown
-	tables: SubscriptionSchemaTables
+	tables: WebhookSchemaTables
 }): string[];
-export { validateSubscriptionFilterForTable, formatSubscriptionSchemaErrors, UpdateSubscriptionRequestSchema, UpdateSubscriptionRequest, SubscriptionSummary, SubscriptionStatusSchema, SubscriptionSchemaTables, SubscriptionSchemaTable, SubscriptionSchemaColumn, SubscriptionRuntimeSchema, SubscriptionFormatSchema, SubscriptionFilterSchema, SubscriptionFilterPrimitiveSchema, SubscriptionFilterPrimitive, SubscriptionFilterOperatorSchema, SubscriptionFilterOperator, SubscriptionFilterClauseSchema, SubscriptionFilterClause, SubscriptionFilter, SubscriptionDetail, SubgraphSyncInfo, SubgraphSummary, SubgraphQueryParams, SubgraphGapsResponse, SubgraphGapRange, SubgraphGapEntry, SubgraphDetail, SubgraphAggregateResponse, SubgraphAggregateParams, SUBSCRIPTION_STATUSES, SUBSCRIPTION_RUNTIMES, SUBSCRIPTION_FORMATS, SUBSCRIPTION_FILTER_OPERATORS, RotateSecretResponse, ReplaySubscriptionRequestSchema, ReplaySubscriptionRequest, ReplayResult, ReindexResponse, ParsedUpdateSubscriptionRequest, ParsedReplaySubscriptionRequest, ParsedCreateSubscriptionRequest, DeploySubgraphResponse, DeploySubgraphRequestSchema, DeploySubgraphRequest, DeliveryRow, DeadRow, CreateSubscriptionResponse, CreateSubscriptionRequestSchema, CreateSubscriptionRequest, CHAIN_TRIGGER_TYPES, CHAIN_TRIGGER_FIELDS };
+export { validateWebhookFilterForTable, formatWebhookSchemaErrors, WebhookSummary, WebhookStatusSchema, WebhookSchemaTables, WebhookSchemaTable, WebhookSchemaColumn, WebhookRuntimeSchema, WebhookFormatSchema, WebhookFilterSchema, WebhookFilterPrimitiveSchema, WebhookFilterPrimitive, WebhookFilterOperatorSchema, WebhookFilterOperator, WebhookFilterClauseSchema, WebhookFilterClause, WebhookFilter, WebhookDetail, WEBHOOK_STATUSES, WEBHOOK_RUNTIMES, WEBHOOK_FORMATS, WEBHOOK_FILTER_OPERATORS, UpdateWebhookRequestSchema, UpdateWebhookRequest, SubgraphSyncInfo, SubgraphSummary, SubgraphQueryParams, SubgraphGapsResponse, SubgraphGapRange, SubgraphGapEntry, SubgraphDetail, SubgraphAggregateResponse, SubgraphAggregateParams, RotateSecretResponse, ReplayWebhookRequestSchema, ReplayWebhookRequest, ReplayResult, ReindexResponse, ParsedUpdateWebhookRequest, ParsedReplayWebhookRequest, ParsedCreateWebhookRequest, DeploySubgraphResponse, DeploySubgraphRequestSchema, DeploySubgraphRequest, DeliveryRow, DeadRow, CreateWebhookResponse, CreateWebhookRequestSchema, CreateWebhookRequest, CHAIN_TRIGGER_TYPES, CHAIN_TRIGGER_FIELDS };

package/dist/src/schemas/index.js

@@ -28,9 +28,9 @@ var DeploySubgraphRequestSchema = z.object({
   dryRun: z.boolean().optional()
 });
 
-// src/schemas/subscriptions.ts
+// src/schemas/webhooks.ts
 import { z as z2 } from "zod";
-var SUBSCRIPTION_FORMATS = [
+var WEBHOOK_FORMATS = [
   "standard-webhooks",
   "inngest",
   "trigger",
@@ -38,14 +38,14 @@ var SUBSCRIPTION_FORMATS = [
   "cloudevents",
   "raw"
 ];
-var SUBSCRIPTION_RUNTIMES = [
+var WEBHOOK_RUNTIMES = [
   "inngest",
   "trigger",
   "cloudflare",
   "node"
 ];
-var SUBSCRIPTION_STATUSES = ["active", "paused", "error"];
-var SUBSCRIPTION_FILTER_OPERATORS = [
+var WEBHOOK_STATUSES = ["active", "paused", "error"];
+var WEBHOOK_FILTER_OPERATORS = [
   "eq",
   "neq",
   "gt",
@@ -57,26 +57,23 @@ var SUBSCRIPTION_FILTER_OPERATORS = [
 var webhookUrl = z2.string().trim().min(1).refine((value) => value.startsWith("http://") || value.startsWith("https://"), "must be an http(s) URL");
 var name = z2.string().trim().min(1).max(128);
 var resourceName = z2.string().trim().min(1).max(128);
-var SubscriptionStatusSchema = z2.enum(SUBSCRIPTION_STATUSES);
-var SubscriptionFormatSchema = z2.enum(SUBSCRIPTION_FORMATS);
-var SubscriptionRuntimeSchema = z2.enum(SUBSCRIPTION_RUNTIMES);
-var SubscriptionFilterPrimitiveSchema = z2.union([z2.string(), z2.number().finite(), z2.boolean()]);
-var SubscriptionFilterOperatorSchema = z2.union([
-  z2.object({ eq: SubscriptionFilterPrimitiveSchema }).strict(),
-  z2.object({ neq: SubscriptionFilterPrimitiveSchema }).strict(),
+var WebhookStatusSchema = z2.enum(WEBHOOK_STATUSES);
+var WebhookFormatSchema = z2.enum(WEBHOOK_FORMATS);
+var WebhookRuntimeSchema = z2.enum(WEBHOOK_RUNTIMES);
+var WebhookFilterPrimitiveSchema = z2.union([z2.string(), z2.number().finite(), z2.boolean()]);
+var WebhookFilterOperatorSchema = z2.union([
+  z2.object({ eq: WebhookFilterPrimitiveSchema }).strict(),
+  z2.object({ neq: WebhookFilterPrimitiveSchema }).strict(),
   z2.object({ gt: z2.union([z2.string(), z2.number().finite()]) }).strict(),
   z2.object({ gte: z2.union([z2.string(), z2.number().finite()]) }).strict(),
   z2.object({ lt: z2.union([z2.string(), z2.number().finite()]) }).strict(),
   z2.object({ lte: z2.union([z2.string(), z2.number().finite()]) }).strict(),
   z2.object({
-    in: z2.array(SubscriptionFilterPrimitiveSchema).min(1)
+    in: z2.array(WebhookFilterPrimitiveSchema).min(1)
   }).strict()
 ]);
-var SubscriptionFilterClauseSchema = z2.union([
-  SubscriptionFilterPrimitiveSchema,
-  SubscriptionFilterOperatorSchema
-]);
-var SubscriptionFilterSchema = z2.record(z2.string().min(1), SubscriptionFilterClauseSchema);
+var WebhookFilterClauseSchema = z2.union([WebhookFilterPrimitiveSchema, WebhookFilterOperatorSchema]);
+var WebhookFilterSchema = z2.record(z2.string().min(1), WebhookFilterClauseSchema);
 var CHAIN_TRIGGER_TYPES = [
   "stx_transfer",
   "stx_mint",
@@ -221,15 +218,15 @@ var CHAIN_TRIGGER_FIELDS = Object.fromEntries(ChainTriggerSchema._zod.def.option
   const type = shape.type._zod.def.values[0];
   return [type, Object.keys(shape).filter((k) => k !== "type")];
 }));
-var CreateSubscriptionRequestSchema = z2.object({
+var CreateWebhookRequestSchema = z2.object({
   name,
   subgraphName: resourceName.optional(),
   tableName: resourceName.optional(),
-  filter: SubscriptionFilterSchema.optional(),
+  filter: WebhookFilterSchema.optional(),
   triggers: ChainTriggersSchema.optional(),
   url: webhookUrl,
-  format: SubscriptionFormatSchema.default("standard-webhooks"),
-  runtime: SubscriptionRuntimeSchema.nullable().optional(),
+  format: WebhookFormatSchema.default("standard-webhooks"),
+  runtime: WebhookRuntimeSchema.nullable().optional(),
   authConfig: z2.record(z2.string(), z2.unknown()).optional(),
   maxRetries: z2.number().int().min(0).max(100).optional(),
   timeoutMs: z2.number().int().min(100).max(300000).optional(),
@@ -243,17 +240,17 @@ var CreateSubscriptionRequestSchema = z2.object({
     return true;
   return v.subgraphName !== undefined && v.tableName !== undefined;
 }, {
-  message: "provide either { subgraphName, tableName } for a subgraph subscription OR { triggers } for a chain subscription — not both"
+  message: "provide either { subgraphName, tableName } for a subgraph webhook OR { triggers } for a chain webhook — not both"
 }).refine((v) => v.filter === undefined || v.triggers === undefined, {
-  message: "`filter` applies to subgraph subscriptions; chain subscriptions use `triggers`",
+  message: "`filter` applies to subgraph webhooks; chain webhooks use `triggers`",
   path: ["filter"]
 });
-var UpdateSubscriptionRequestSchema = z2.object({
+var UpdateWebhookRequestSchema = z2.object({
   name: name.optional(),
   url: webhookUrl.optional(),
-  filter: SubscriptionFilterSchema.optional(),
-  format: SubscriptionFormatSchema.optional(),
-  runtime: SubscriptionRuntimeSchema.nullable().optional(),
+  filter: WebhookFilterSchema.optional(),
+  format: WebhookFormatSchema.optional(),
+  runtime: WebhookRuntimeSchema.nullable().optional(),
   authConfig: z2.record(z2.string(), z2.unknown()).optional(),
   maxRetries: z2.number().int().min(0).max(100).optional(),
   timeoutMs: z2.number().int().min(100).max(300000).optional(),
@@ -261,7 +258,7 @@ var UpdateSubscriptionRequestSchema = z2.object({
 }).refine((value) => Object.keys(value).length > 0, {
   message: "At least one field must be provided"
 });
-var ReplaySubscriptionRequestSchema = z2.object({
+var ReplayWebhookRequestSchema = z2.object({
   fromBlock: z2.number().int().nonnegative(),
   toBlock: z2.number().int().nonnegative(),
   force: z2.string().trim().min(1).max(64).optional()
@@ -355,7 +352,7 @@ var COMPARISON_COLUMN_TYPES = new Set(["uint", "int", "timestamp"]);
 function formatIssuePath(path) {
   return path.length > 0 ? `${path.map(String).join(".")}: ` : "";
 }
-function formatSubscriptionSchemaErrors(error) {
+function formatWebhookSchemaErrors(error) {
   return error.issues.map((issue) => `${formatIssuePath(issue.path)}${issue.message}`);
 }
 function operatorForClause(clause) {
@@ -364,7 +361,7 @@ function operatorForClause(clause) {
   }
   return Object.keys(clause)[0] ?? "eq";
 }
-function validateSubscriptionFilterForTable(input) {
+function validateWebhookFilterForTable(input) {
   const errors = [];
   const table = input.tables[input.tableName];
   if (!table) {
@@ -374,9 +371,9 @@ function validateSubscriptionFilterForTable(input) {
   }
   if (input.filter === undefined)
     return errors;
-  const parsed = SubscriptionFilterSchema.safeParse(input.filter);
+  const parsed = WebhookFilterSchema.safeParse(input.filter);
   if (!parsed.success) {
-    return formatSubscriptionSchemaErrors(parsed.error);
+    return formatWebhookSchemaErrors(parsed.error);
   }
   for (const [field, clause] of Object.entries(parsed.data)) {
     const column = table.columns[field];
@@ -386,7 +383,7 @@ function validateSubscriptionFilterForTable(input) {
     }
     const columnType = typeof column.type === "string" ? column.type.toLowerCase() : "";
     if (!SCALAR_COLUMN_TYPES.has(columnType)) {
-      errors.push(`Filter field "${field}" has unsupported type "${columnType || "unknown"}"; subscription filters require scalar columns.`);
+      errors.push(`Filter field "${field}" has unsupported type "${columnType || "unknown"}"; webhook filters require scalar columns.`);
       continue;
     }
     const operator = operatorForClause(clause);
@@ -397,26 +394,26 @@ function validateSubscriptionFilterForTable(input) {
   return errors;
 }
 export {
-  validateSubscriptionFilterForTable,
-  formatSubscriptionSchemaErrors,
-  UpdateSubscriptionRequestSchema,
-  SubscriptionStatusSchema,
-  SubscriptionRuntimeSchema,
-  SubscriptionFormatSchema,
-  SubscriptionFilterSchema,
-  SubscriptionFilterPrimitiveSchema,
-  SubscriptionFilterOperatorSchema,
-  SubscriptionFilterClauseSchema,
-  SUBSCRIPTION_STATUSES,
-  SUBSCRIPTION_RUNTIMES,
-  SUBSCRIPTION_FORMATS,
-  SUBSCRIPTION_FILTER_OPERATORS,
-  ReplaySubscriptionRequestSchema,
+  validateWebhookFilterForTable,
+  formatWebhookSchemaErrors,
+  WebhookStatusSchema,
+  WebhookRuntimeSchema,
+  WebhookFormatSchema,
+  WebhookFilterSchema,
+  WebhookFilterPrimitiveSchema,
+  WebhookFilterOperatorSchema,
+  WebhookFilterClauseSchema,
+  WEBHOOK_STATUSES,
+  WEBHOOK_RUNTIMES,
+  WEBHOOK_FORMATS,
+  WEBHOOK_FILTER_OPERATORS,
+  UpdateWebhookRequestSchema,
+  ReplayWebhookRequestSchema,
   DeploySubgraphRequestSchema,
-  CreateSubscriptionRequestSchema,
+  CreateWebhookRequestSchema,
   CHAIN_TRIGGER_TYPES,
   CHAIN_TRIGGER_FIELDS
 };
 
-//# debugId=7B1B5B4BE50333EE64756E2164756E21
+//# debugId=6EDFF4FE6F27581C64756E2164756E21
 //# sourceMappingURL=index.js.map