@contractspec/lib.contracts-integrations 2.0.0

package/dist/integrations/integrations.capability.d.ts

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

package/dist/integrations/integrations.capability.js

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

package/dist/integrations/integrations.feature.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Platform Integrations feature module that bundles
+ * integration connection management capabilities.
+ */
+export declare const IntegrationsFeature: import("@contractspec/lib.contracts-spec").FeatureModuleSpec;

package/dist/integrations/integrations.feature.js

@@ -0,0 +1,33 @@
+// @bun
+// src/integrations/integrations.feature.ts
+import { defineFeature } from "@contractspec/lib.contracts-spec/features";
+var IntegrationsFeature = defineFeature({
+  meta: {
+    key: "platform.integrations",
+    version: "1.0.0",
+    title: "Platform Integrations",
+    description: "Manage integration connections to external providers (e.g., Stripe, Qdrant)",
+    domain: "platform",
+    owners: ["@platform.integrations"],
+    tags: ["integrations", "connections", "platform"],
+    stability: "experimental"
+  },
+  operations: [
+    { key: "integrations.connection.create", version: "1.0.0" },
+    { key: "integrations.connection.update", version: "1.0.0" },
+    { key: "integrations.connection.delete", version: "1.0.0" },
+    { key: "integrations.connection.list", version: "1.0.0" },
+    { key: "integrations.connection.test", version: "1.0.0" }
+  ],
+  events: [],
+  presentations: [],
+  opToPresentation: [],
+  presentationsTargets: [],
+  capabilities: {
+    provides: [{ key: "integrations", version: "1.0.0" }],
+    requires: [{ key: "identity", version: "1.0.0" }]
+  }
+});
+export {
+  IntegrationsFeature
+};

package/dist/integrations/meeting-recorder/contracts/index.d.ts

@@ -0,0 +1,7 @@
+import type { OperationSpecRegistry } from '@contractspec/lib.contracts-spec/operations/registry';
+import { MeetingRecorderGetMeeting, MeetingRecorderListMeetings } from './meetings';
+import { MeetingRecorderGetTranscript, MeetingRecorderSyncTranscript } from './transcripts';
+import { MeetingRecorderWebhookIngest } from './webhooks';
+export { MeetingRecorderGetMeeting, MeetingRecorderListMeetings, MeetingRecorderGetTranscript, MeetingRecorderSyncTranscript, MeetingRecorderWebhookIngest, };
+export * from '../meeting-recorder.feature';
+export declare function registerMeetingRecorderContracts(registry: OperationSpecRegistry): OperationSpecRegistry;

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

@@ -0,0 +1,474 @@
+// @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/meetings.ts
+import { ScalarTypeEnum as ScalarTypeEnum2, SchemaModel as SchemaModel2 } from "@contractspec/lib.schema";
+import {
+  defineQuery
+} from "@contractspec/lib.contracts-spec/operations";
+var MeetingRecorderListMeetingsInput = new SchemaModel2({
+  name: "MeetingRecorderListMeetingsInput",
+  description: "Parameters for listing meetings from a meeting recorder provider.",
+  fields: {
+    tenantId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum2.ID(), isOptional: true },
+    from: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+    to: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+    cursor: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    pageSize: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
+    query: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    organizerEmail: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: true
+    },
+    participantEmail: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: true
+    },
+    includeTranscript: { type: ScalarTypeEnum2.Boolean(), isOptional: true },
+    includeSummary: { type: ScalarTypeEnum2.Boolean(), isOptional: true }
+  }
+});
+var MeetingRecorderListMeetingsOutput = new SchemaModel2({
+  name: "MeetingRecorderListMeetingsOutput",
+  description: "Paginated list of meetings for a recorder provider.",
+  fields: {
+    meetings: {
+      type: MeetingRecord,
+      isOptional: false,
+      isArray: true
+    },
+    nextCursor: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    hasMore: { type: ScalarTypeEnum2.Boolean(), isOptional: true }
+  }
+});
+var MeetingRecorderGetMeetingInput = new SchemaModel2({
+  name: "MeetingRecorderGetMeetingInput",
+  description: "Parameters for retrieving a single meeting record.",
+  fields: {
+    tenantId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    meetingId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum2.ID(), isOptional: true },
+    includeTranscript: { type: ScalarTypeEnum2.Boolean(), isOptional: true },
+    includeSummary: { type: ScalarTypeEnum2.Boolean(), isOptional: true }
+  }
+});
+var MeetingRecorderListMeetings = defineQuery({
+  meta: {
+    key: "meeting-recorder.meetings.list",
+    version: "1.0.0",
+    description: "List meetings recorded by the configured meeting provider.",
+    goal: "Provide downstream workflows with recent meetings and metadata.",
+    context: "Used by integration hubs and sync workflows to enumerate meetings before pulling transcripts.",
+    owners: ["@platform.integrations"],
+    tags: ["meeting-recorder", "meetings", "transcripts"],
+    stability: "experimental"
+  },
+  io: {
+    input: MeetingRecorderListMeetingsInput,
+    output: MeetingRecorderListMeetingsOutput
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var MeetingRecorderGetMeeting = defineQuery({
+  meta: {
+    key: "meeting-recorder.meetings.get",
+    version: "1.0.0",
+    description: "Retrieve metadata for a single meeting recording.",
+    goal: "Allow downstream experiences to display detailed meeting metadata.",
+    context: "Used when drilling into a specific meeting from a transcript or integration dashboard.",
+    owners: ["@platform.integrations"],
+    tags: ["meeting-recorder", "meetings"],
+    stability: "experimental"
+  },
+  io: {
+    input: MeetingRecorderGetMeetingInput,
+    output: MeetingRecord
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var meetingRecorderMeetingContracts = {
+  MeetingRecorderListMeetings,
+  MeetingRecorderGetMeeting
+};
+function registerMeetingRecorderMeetingContracts(registry) {
+  return registry.register(MeetingRecorderListMeetings).register(MeetingRecorderGetMeeting);
+}
+
+// src/integrations/meeting-recorder/telemetry.ts
+var MEETING_RECORDER_PII_FIELDS = [
+  "email",
+  "organizerEmail",
+  "participantEmail",
+  "participants",
+  "invitees",
+  "attendees",
+  "speakerName",
+  "speakerEmail",
+  "name",
+  "phone",
+  "phoneNumber",
+  "displayName"
+];
+var MEETING_RECORDER_TELEMETRY_EVENTS = {
+  meetingsSynced: "meeting-recorder.meetings.synced",
+  meetingsSyncFailed: "meeting-recorder.meetings.sync_failed",
+  transcriptsFetched: "meeting-recorder.transcripts.fetched",
+  transcriptsFetchFailed: "meeting-recorder.transcripts.fetch_failed",
+  transcriptsSynced: "meeting-recorder.transcripts.synced",
+  transcriptsSyncFailed: "meeting-recorder.transcripts.sync_failed",
+  webhookReceived: "meeting-recorder.webhooks.received",
+  webhookRejected: "meeting-recorder.webhooks.rejected"
+};
+function redactMeetingRecorderTelemetryPayload(payload) {
+  const redacted = {};
+  for (const [key, value] of Object.entries(payload)) {
+    if (MEETING_RECORDER_PII_FIELDS.includes(key)) {
+      redacted[key] = maskValue(value);
+    } else if (Array.isArray(value)) {
+      redacted[key] = value.map((item) => typeof item === "object" && item !== null ? redactMeetingRecorderTelemetryPayload(item) : item);
+    } else if (typeof value === "object" && value !== null) {
+      redacted[key] = redactMeetingRecorderTelemetryPayload(value);
+    } else {
+      redacted[key] = value;
+    }
+  }
+  return redacted;
+}
+function maskValue(value) {
+  if (value == null)
+    return "";
+  const str = String(value);
+  if (str.length <= 4)
+    return "*".repeat(str.length);
+  return `${"*".repeat(Math.max(str.length - 4, 0))}${str.slice(-4)}`;
+}
+
+// src/integrations/meeting-recorder/contracts/transcripts.ts
+import { ScalarTypeEnum as ScalarTypeEnum3, SchemaModel as SchemaModel3 } from "@contractspec/lib.schema";
+import {
+  defineCommand,
+  defineQuery as defineQuery2
+} from "@contractspec/lib.contracts-spec/operations";
+var MeetingRecorderGetTranscriptInput = new SchemaModel3({
+  name: "MeetingRecorderGetTranscriptInput",
+  description: "Parameters for fetching a meeting transcript.",
+  fields: {
+    tenantId: { type: ScalarTypeEnum3.ID(), isOptional: false },
+    meetingId: { type: ScalarTypeEnum3.ID(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum3.ID(), isOptional: true },
+    includeSegments: { type: ScalarTypeEnum3.Boolean(), isOptional: true },
+    format: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true }
+  }
+});
+var MeetingRecorderSyncTranscriptInput = new SchemaModel3({
+  name: "MeetingRecorderSyncTranscriptInput",
+  description: "Command payload to synchronise meeting transcripts.",
+  fields: {
+    tenantId: { type: ScalarTypeEnum3.ID(), isOptional: false },
+    meetingId: { type: ScalarTypeEnum3.ID(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum3.ID(), isOptional: true },
+    forceRefresh: { type: ScalarTypeEnum3.Boolean(), isOptional: true },
+    triggerWebhooks: { type: ScalarTypeEnum3.Boolean(), isOptional: true }
+  }
+});
+var MeetingRecorderSyncTranscriptOutput = new SchemaModel3({
+  name: "MeetingRecorderSyncTranscriptOutput",
+  description: "Result of a transcript synchronisation run.",
+  fields: {
+    synced: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    failed: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    errors: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    nextSyncSuggestedAt: {
+      type: ScalarTypeEnum3.DateTime(),
+      isOptional: true
+    }
+  }
+});
+var MeetingRecorderGetTranscript = defineQuery2({
+  meta: {
+    key: "meeting-recorder.transcripts.get",
+    version: "1.0.0",
+    description: "Fetch the transcript for a specific meeting recording.",
+    goal: "Expose meeting transcripts for downstream knowledge and analytics flows.",
+    context: "Used by agents and dashboards to access the transcript for a selected meeting.",
+    owners: ["@platform.integrations"],
+    tags: ["meeting-recorder", "transcripts"],
+    stability: "experimental"
+  },
+  io: {
+    input: MeetingRecorderGetTranscriptInput,
+    output: MeetingTranscriptRecord
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var MeetingRecorderSyncTranscript = defineCommand({
+  meta: {
+    key: "meeting-recorder.transcripts.sync",
+    version: "1.0.0",
+    description: "Trigger a transcript sync from the meeting recorder provider.",
+    goal: "Keep canonical transcripts aligned with external meeting providers.",
+    context: "Invoked by scheduled jobs or webhooks when new transcripts are ready.",
+    owners: ["@platform.integrations"],
+    tags: ["meeting-recorder", "transcripts", "sync"],
+    stability: "experimental"
+  },
+  io: {
+    input: MeetingRecorderSyncTranscriptInput,
+    output: MeetingRecorderSyncTranscriptOutput
+  },
+  policy: {
+    auth: "admin"
+  },
+  telemetry: {
+    success: {
+      event: { key: MEETING_RECORDER_TELEMETRY_EVENTS.transcriptsSynced },
+      properties: ({ input, output }) => {
+        const payload = input;
+        const result = output;
+        return {
+          tenantId: payload?.tenantId,
+          meetingId: payload?.meetingId,
+          synced: result?.synced,
+          failed: result?.failed
+        };
+      }
+    },
+    failure: {
+      event: { key: MEETING_RECORDER_TELEMETRY_EVENTS.transcriptsSyncFailed },
+      properties: ({ input, error }) => {
+        const payload = input;
+        return {
+          tenantId: payload?.tenantId,
+          meetingId: payload?.meetingId,
+          error: error instanceof Error ? error.message : String(error ?? "unknown")
+        };
+      }
+    }
+  }
+});
+var meetingRecorderTranscriptContracts = {
+  MeetingRecorderGetTranscript,
+  MeetingRecorderSyncTranscript
+};
+function registerMeetingRecorderTranscriptContracts(registry) {
+  return registry.register(MeetingRecorderGetTranscript).register(MeetingRecorderSyncTranscript);
+}
+
+// src/integrations/meeting-recorder/contracts/webhooks.ts
+import { ScalarTypeEnum as ScalarTypeEnum4, SchemaModel as SchemaModel4 } from "@contractspec/lib.schema";
+import {
+  defineCommand as defineCommand2
+} from "@contractspec/lib.contracts-spec/operations";
+var MeetingRecorderWebhookIngestInput = new SchemaModel4({
+  name: "MeetingRecorderWebhookIngestInput",
+  description: "Payload for ingesting a meeting recorder webhook event.",
+  fields: {
+    tenantId: { type: ScalarTypeEnum4.ID(), isOptional: false },
+    providerKey: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum4.ID(), isOptional: true },
+    webhookId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    headers: { type: ScalarTypeEnum4.JSON(), isOptional: true },
+    payload: { type: ScalarTypeEnum4.JSON(), isOptional: false },
+    receivedAt: { type: ScalarTypeEnum4.DateTime(), isOptional: true }
+  }
+});
+var MeetingRecorderWebhookIngestOutput = new SchemaModel4({
+  name: "MeetingRecorderWebhookIngestOutput",
+  description: "Result of processing a meeting recorder webhook.",
+  fields: {
+    accepted: { type: ScalarTypeEnum4.Boolean(), isOptional: false },
+    event: { type: MeetingRecorderWebhookEventRecord, isOptional: true }
+  }
+});
+var MeetingRecorderWebhookIngest = defineCommand2({
+  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);
+}
+
+// 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" }]
+  }
+});
+// src/integrations/meeting-recorder/contracts/index.ts
+function registerMeetingRecorderContracts(registry) {
+  return registerMeetingRecorderWebhookContracts(registerMeetingRecorderTranscriptContracts(registerMeetingRecorderMeetingContracts(registry)));
+}
+export {
+  registerMeetingRecorderContracts,
+  MeetingRecorderWebhookIngest,
+  MeetingRecorderSyncTranscript,
+  MeetingRecorderListMeetings,
+  MeetingRecorderGetTranscript,
+  MeetingRecorderGetMeeting,
+  MeetingRecorderFeature
+};