@contractspec/lib.contracts-integrations 2.0.0

package/dist/integrations/meeting-recorder/contracts/webhooks.js

@@ -0,0 +1,172 @@
+// @bun
+// src/integrations/meeting-recorder/models.ts
+import { ScalarTypeEnum, SchemaModel } from "@contractspec/lib.schema";
+var MeetingParticipantRecord = new SchemaModel({
+  name: "MeetingParticipantRecord",
+  description: "Canonical participant entry for meetings and transcripts from recorder providers.",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    externalId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    email: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    role: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    isExternal: { type: ScalarTypeEnum.Boolean(), isOptional: true },
+    metadata: { type: ScalarTypeEnum.JSONObject(), isOptional: true }
+  }
+});
+var MeetingTranscriptSegmentRecord = new SchemaModel({
+  name: "MeetingTranscriptSegmentRecord",
+  description: "A single transcript segment with speaker attribution.",
+  fields: {
+    index: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    speakerId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    speakerName: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    speakerEmail: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    text: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    startTimeMs: { type: ScalarTypeEnum.Float_unsecure(), isOptional: true },
+    endTimeMs: { type: ScalarTypeEnum.Float_unsecure(), isOptional: true },
+    startTime: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    endTime: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    confidence: { type: ScalarTypeEnum.Float_unsecure(), isOptional: true },
+    metadata: { type: ScalarTypeEnum.JSONObject(), isOptional: true }
+  }
+});
+var MeetingRecord = new SchemaModel({
+  name: "MeetingRecord",
+  description: "Canonical meeting metadata synced from meeting recorder providers.",
+  fields: {
+    id: { type: ScalarTypeEnum.ID(), isOptional: false },
+    tenantId: { type: ScalarTypeEnum.ID(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum.ID(), isOptional: false },
+    externalId: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    title: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    summary: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    organizer: { type: MeetingParticipantRecord, isOptional: true },
+    invitees: {
+      type: MeetingParticipantRecord,
+      isArray: true,
+      isOptional: true
+    },
+    participants: {
+      type: MeetingParticipantRecord,
+      isArray: true,
+      isOptional: true
+    },
+    scheduledStartAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    scheduledEndAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    recordingStartAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    recordingEndAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    durationSeconds: {
+      type: ScalarTypeEnum.Float_unsecure(),
+      isOptional: true
+    },
+    meetingUrl: { type: ScalarTypeEnum.URL(), isOptional: true },
+    recordingUrl: { type: ScalarTypeEnum.URL(), isOptional: true },
+    shareUrl: { type: ScalarTypeEnum.URL(), isOptional: true },
+    sourcePlatform: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    language: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    transcriptAvailable: { type: ScalarTypeEnum.Boolean(), isOptional: true },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    updatedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    metadata: { type: ScalarTypeEnum.JSONObject(), isOptional: true }
+  }
+});
+var MeetingTranscriptRecord = new SchemaModel({
+  name: "MeetingTranscriptRecord",
+  description: "Canonical transcript payload for a recorded meeting.",
+  fields: {
+    id: { type: ScalarTypeEnum.ID(), isOptional: false },
+    meetingId: { type: ScalarTypeEnum.ID(), isOptional: false },
+    tenantId: { type: ScalarTypeEnum.ID(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum.ID(), isOptional: false },
+    externalId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    format: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    text: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    segments: {
+      type: MeetingTranscriptSegmentRecord,
+      isArray: true,
+      isOptional: true
+    },
+    language: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    sourceUrl: { type: ScalarTypeEnum.URL(), isOptional: true },
+    generatedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    metadata: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    raw: { type: ScalarTypeEnum.JSON(), isOptional: true }
+  }
+});
+var MeetingRecorderWebhookEventRecord = new SchemaModel({
+  name: "MeetingRecorderWebhookEventRecord",
+  description: "Normalized webhook event from a meeting recorder provider.",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    providerKey: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    eventType: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    meetingId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    transcriptId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    recordingId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    receivedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    verified: { type: ScalarTypeEnum.Boolean(), isOptional: true },
+    payload: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    metadata: { type: ScalarTypeEnum.JSONObject(), isOptional: true }
+  }
+});
+
+// src/integrations/meeting-recorder/contracts/webhooks.ts
+import { ScalarTypeEnum as ScalarTypeEnum2, SchemaModel as SchemaModel2 } from "@contractspec/lib.schema";
+import {
+  defineCommand
+} from "@contractspec/lib.contracts-spec/operations";
+var MeetingRecorderWebhookIngestInput = new SchemaModel2({
+  name: "MeetingRecorderWebhookIngestInput",
+  description: "Payload for ingesting a meeting recorder webhook event.",
+  fields: {
+    tenantId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    providerKey: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum2.ID(), isOptional: true },
+    webhookId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    headers: { type: ScalarTypeEnum2.JSON(), isOptional: true },
+    payload: { type: ScalarTypeEnum2.JSON(), isOptional: false },
+    receivedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: true }
+  }
+});
+var MeetingRecorderWebhookIngestOutput = new SchemaModel2({
+  name: "MeetingRecorderWebhookIngestOutput",
+  description: "Result of processing a meeting recorder webhook.",
+  fields: {
+    accepted: { type: ScalarTypeEnum2.Boolean(), isOptional: false },
+    event: { type: MeetingRecorderWebhookEventRecord, isOptional: true }
+  }
+});
+var MeetingRecorderWebhookIngest = defineCommand({
+  meta: {
+    key: "meeting-recorder.webhooks.ingest",
+    version: "1.0.0",
+    description: "Ingest a webhook from a meeting recorder provider.",
+    goal: "Trigger transcript syncs or downstream workflows without polling.",
+    context: "Used by webhook handlers to validate and normalize provider webhook events.",
+    owners: ["@platform.integrations"],
+    tags: ["meeting-recorder", "webhooks", "transcripts"],
+    stability: "experimental"
+  },
+  io: {
+    input: MeetingRecorderWebhookIngestInput,
+    output: MeetingRecorderWebhookIngestOutput
+  },
+  policy: {
+    auth: "admin"
+  }
+});
+var meetingRecorderWebhookContracts = {
+  MeetingRecorderWebhookIngest
+};
+function registerMeetingRecorderWebhookContracts(registry) {
+  return registry.register(MeetingRecorderWebhookIngest);
+}
+export {
+  registerMeetingRecorderWebhookContracts,
+  meetingRecorderWebhookContracts,
+  MeetingRecorderWebhookIngest
+};

package/dist/integrations/meeting-recorder/meeting-recorder.capability.d.ts

@@ -0,0 +1 @@
+export declare const MeetingRecorderCapability: import("@contractspec/lib.contracts-spec").CapabilitySpec;

package/dist/integrations/meeting-recorder/meeting-recorder.capability.js

@@ -0,0 +1,18 @@
+// @bun
+// src/integrations/meeting-recorder/meeting-recorder.capability.ts
+import { defineCapability } from "@contractspec/lib.contracts-spec/capabilities";
+import { StabilityEnum } from "@contractspec/lib.contracts-spec/ownership";
+var MeetingRecorderCapability = defineCapability({
+  meta: {
+    key: "meeting-recorder",
+    version: "1.0.0",
+    kind: "integration",
+    stability: StabilityEnum.Experimental,
+    description: "Meeting recorder integrations capability",
+    owners: ["@platform.integrations"],
+    tags: ["meeting-recorder", "transcripts", "integrations"]
+  }
+});
+export {
+  MeetingRecorderCapability
+};

package/dist/integrations/meeting-recorder/meeting-recorder.feature.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Meeting recorder feature module that bundles meeting metadata,
+ * transcript fetch, and webhook ingestion capabilities.
+ */
+export declare const MeetingRecorderFeature: import("@contractspec/lib.contracts-spec").FeatureModuleSpec;

package/dist/integrations/meeting-recorder/meeting-recorder.feature.js

@@ -0,0 +1,33 @@
+// @bun
+// src/integrations/meeting-recorder/meeting-recorder.feature.ts
+import { defineFeature } from "@contractspec/lib.contracts-spec/features";
+var MeetingRecorderFeature = defineFeature({
+  meta: {
+    key: "meeting-recorder",
+    version: "1.0.0",
+    title: "Meeting Recorder Integration",
+    description: "Meeting metadata, transcript retrieval, and webhook ingestion for meeting recorder providers.",
+    domain: "integrations",
+    owners: ["@platform.integrations"],
+    tags: ["meeting-recorder", "transcripts", "integrations"],
+    stability: "experimental"
+  },
+  operations: [
+    { key: "meeting-recorder.meetings.list", version: "1.0.0" },
+    { key: "meeting-recorder.meetings.get", version: "1.0.0" },
+    { key: "meeting-recorder.transcripts.get", version: "1.0.0" },
+    { key: "meeting-recorder.transcripts.sync", version: "1.0.0" },
+    { key: "meeting-recorder.webhooks.ingest", version: "1.0.0" }
+  ],
+  events: [],
+  presentations: [],
+  opToPresentation: [],
+  presentationsTargets: [],
+  capabilities: {
+    provides: [{ key: "meeting-recorder", version: "1.0.0" }],
+    requires: [{ key: "identity", version: "1.0.0" }]
+  }
+});
+export {
+  MeetingRecorderFeature
+};

package/dist/integrations/meeting-recorder/models.d.ts

@@ -0,0 +1,402 @@
+import { SchemaModel } from '@contractspec/lib.schema';
+export declare const MeetingParticipantRecord: SchemaModel<{
+    id: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    externalId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    name: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    email: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    role: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    isExternal: {
+        type: import("@contractspec/lib.schema").FieldType<boolean, boolean>;
+        isOptional: true;
+    };
+    metadata: {
+        type: import("@contractspec/lib.schema").FieldType<Record<string, unknown>, Record<string, unknown>>;
+        isOptional: true;
+    };
+}>;
+export declare const MeetingTranscriptSegmentRecord: SchemaModel<{
+    index: {
+        type: import("@contractspec/lib.schema").FieldType<number, number>;
+        isOptional: true;
+    };
+    speakerId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    speakerName: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    speakerEmail: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    text: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    startTimeMs: {
+        type: import("@contractspec/lib.schema").FieldType<number, number>;
+        isOptional: true;
+    };
+    endTimeMs: {
+        type: import("@contractspec/lib.schema").FieldType<number, number>;
+        isOptional: true;
+    };
+    startTime: {
+        type: import("@contractspec/lib.schema").FieldType<Date, string>;
+        isOptional: true;
+    };
+    endTime: {
+        type: import("@contractspec/lib.schema").FieldType<Date, string>;
+        isOptional: true;
+    };
+    confidence: {
+        type: import("@contractspec/lib.schema").FieldType<number, number>;
+        isOptional: true;
+    };
+    metadata: {
+        type: import("@contractspec/lib.schema").FieldType<Record<string, unknown>, Record<string, unknown>>;
+        isOptional: true;
+    };
+}>;
+export declare const MeetingRecord: SchemaModel<{
+    id: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    tenantId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    connectionId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    externalId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    title: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    summary: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    organizer: {
+        type: SchemaModel<{
+            id: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            externalId: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            name: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            email: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            role: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            isExternal: {
+                type: import("@contractspec/lib.schema").FieldType<boolean, boolean>;
+                isOptional: true;
+            };
+            metadata: {
+                type: import("@contractspec/lib.schema").FieldType<Record<string, unknown>, Record<string, unknown>>;
+                isOptional: true;
+            };
+        }>;
+        isOptional: true;
+    };
+    invitees: {
+        type: SchemaModel<{
+            id: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            externalId: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            name: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            email: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            role: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            isExternal: {
+                type: import("@contractspec/lib.schema").FieldType<boolean, boolean>;
+                isOptional: true;
+            };
+            metadata: {
+                type: import("@contractspec/lib.schema").FieldType<Record<string, unknown>, Record<string, unknown>>;
+                isOptional: true;
+            };
+        }>;
+        isArray: true;
+        isOptional: true;
+    };
+    participants: {
+        type: SchemaModel<{
+            id: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            externalId: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            name: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            email: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            role: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            isExternal: {
+                type: import("@contractspec/lib.schema").FieldType<boolean, boolean>;
+                isOptional: true;
+            };
+            metadata: {
+                type: import("@contractspec/lib.schema").FieldType<Record<string, unknown>, Record<string, unknown>>;
+                isOptional: true;
+            };
+        }>;
+        isArray: true;
+        isOptional: true;
+    };
+    scheduledStartAt: {
+        type: import("@contractspec/lib.schema").FieldType<Date, string>;
+        isOptional: true;
+    };
+    scheduledEndAt: {
+        type: import("@contractspec/lib.schema").FieldType<Date, string>;
+        isOptional: true;
+    };
+    recordingStartAt: {
+        type: import("@contractspec/lib.schema").FieldType<Date, string>;
+        isOptional: true;
+    };
+    recordingEndAt: {
+        type: import("@contractspec/lib.schema").FieldType<Date, string>;
+        isOptional: true;
+    };
+    durationSeconds: {
+        type: import("@contractspec/lib.schema").FieldType<number, number>;
+        isOptional: true;
+    };
+    meetingUrl: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    recordingUrl: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    shareUrl: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    sourcePlatform: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    language: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    transcriptAvailable: {
+        type: import("@contractspec/lib.schema").FieldType<boolean, boolean>;
+        isOptional: true;
+    };
+    createdAt: {
+        type: import("@contractspec/lib.schema").FieldType<Date, string>;
+        isOptional: true;
+    };
+    updatedAt: {
+        type: import("@contractspec/lib.schema").FieldType<Date, string>;
+        isOptional: true;
+    };
+    metadata: {
+        type: import("@contractspec/lib.schema").FieldType<Record<string, unknown>, Record<string, unknown>>;
+        isOptional: true;
+    };
+}>;
+export declare const MeetingTranscriptRecord: SchemaModel<{
+    id: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    meetingId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    tenantId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    connectionId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    externalId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    format: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    text: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    segments: {
+        type: SchemaModel<{
+            index: {
+                type: import("@contractspec/lib.schema").FieldType<number, number>;
+                isOptional: true;
+            };
+            speakerId: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            speakerName: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            speakerEmail: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            text: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: false;
+            };
+            startTimeMs: {
+                type: import("@contractspec/lib.schema").FieldType<number, number>;
+                isOptional: true;
+            };
+            endTimeMs: {
+                type: import("@contractspec/lib.schema").FieldType<number, number>;
+                isOptional: true;
+            };
+            startTime: {
+                type: import("@contractspec/lib.schema").FieldType<Date, string>;
+                isOptional: true;
+            };
+            endTime: {
+                type: import("@contractspec/lib.schema").FieldType<Date, string>;
+                isOptional: true;
+            };
+            confidence: {
+                type: import("@contractspec/lib.schema").FieldType<number, number>;
+                isOptional: true;
+            };
+            metadata: {
+                type: import("@contractspec/lib.schema").FieldType<Record<string, unknown>, Record<string, unknown>>;
+                isOptional: true;
+            };
+        }>;
+        isArray: true;
+        isOptional: true;
+    };
+    language: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    sourceUrl: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    generatedAt: {
+        type: import("@contractspec/lib.schema").FieldType<Date, string>;
+        isOptional: true;
+    };
+    metadata: {
+        type: import("@contractspec/lib.schema").FieldType<Record<string, unknown>, Record<string, unknown>>;
+        isOptional: true;
+    };
+    raw: {
+        type: import("@contractspec/lib.schema").FieldType<unknown, unknown>;
+        isOptional: true;
+    };
+}>;
+export declare const MeetingRecorderWebhookEventRecord: SchemaModel<{
+    id: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    providerKey: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    eventType: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    meetingId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    transcriptId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    recordingId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    receivedAt: {
+        type: import("@contractspec/lib.schema").FieldType<Date, string>;
+        isOptional: true;
+    };
+    verified: {
+        type: import("@contractspec/lib.schema").FieldType<boolean, boolean>;
+        isOptional: true;
+    };
+    payload: {
+        type: import("@contractspec/lib.schema").FieldType<unknown, unknown>;
+        isOptional: true;
+    };
+    metadata: {
+        type: import("@contractspec/lib.schema").FieldType<Record<string, unknown>, Record<string, unknown>>;
+        isOptional: true;
+    };
+}>;