@contractspec/lib.contracts 1.56.0 → 1.57.0

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

@@ -0,0 +1,149 @@
+import { defineQuery } from "../../../operations/operation.js";
+import "../../../operations/index.js";
+import { MeetingRecord } from "../models.js";
+import { ScalarTypeEnum, SchemaModel } from "@contractspec/lib.schema";
+
+//#region src/integrations/meeting-recorder/contracts/meetings.ts
+const MeetingRecorderListMeetingsInput = new SchemaModel({
+	name: "MeetingRecorderListMeetingsInput",
+	description: "Parameters for listing meetings from a meeting recorder provider.",
+	fields: {
+		tenantId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: false
+		},
+		connectionId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: true
+		},
+		from: {
+			type: ScalarTypeEnum.DateTime(),
+			isOptional: true
+		},
+		to: {
+			type: ScalarTypeEnum.DateTime(),
+			isOptional: true
+		},
+		cursor: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: true
+		},
+		pageSize: {
+			type: ScalarTypeEnum.Int_unsecure(),
+			isOptional: true
+		},
+		query: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: true
+		},
+		organizerEmail: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: true
+		},
+		participantEmail: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: true
+		},
+		includeTranscript: {
+			type: ScalarTypeEnum.Boolean(),
+			isOptional: true
+		},
+		includeSummary: {
+			type: ScalarTypeEnum.Boolean(),
+			isOptional: true
+		}
+	}
+});
+const MeetingRecorderListMeetingsOutput = new SchemaModel({
+	name: "MeetingRecorderListMeetingsOutput",
+	description: "Paginated list of meetings for a recorder provider.",
+	fields: {
+		meetings: {
+			type: MeetingRecord,
+			isOptional: false,
+			isArray: true
+		},
+		nextCursor: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: true
+		},
+		hasMore: {
+			type: ScalarTypeEnum.Boolean(),
+			isOptional: true
+		}
+	}
+});
+const MeetingRecorderGetMeetingInput = new SchemaModel({
+	name: "MeetingRecorderGetMeetingInput",
+	description: "Parameters for retrieving a single meeting record.",
+	fields: {
+		tenantId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: false
+		},
+		meetingId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: false
+		},
+		connectionId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: true
+		},
+		includeTranscript: {
+			type: ScalarTypeEnum.Boolean(),
+			isOptional: true
+		},
+		includeSummary: {
+			type: ScalarTypeEnum.Boolean(),
+			isOptional: true
+		}
+	}
+});
+const 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" }
+});
+const 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" }
+});
+const meetingRecorderMeetingContracts = {
+	MeetingRecorderListMeetings,
+	MeetingRecorderGetMeeting
+};
+function registerMeetingRecorderMeetingContracts(registry) {
+	return registry.register(MeetingRecorderListMeetings).register(MeetingRecorderGetMeeting);
+}
+
+//#endregion
+export { MeetingRecorderGetMeeting, MeetingRecorderListMeetings, meetingRecorderMeetingContracts, registerMeetingRecorderMeetingContracts };

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

@@ -0,0 +1,173 @@
+import { AnyOperationSpec, OperationSpec } from "../../../operations/operation.js";
+import "../../../operations/index.js";
+import { OperationSpecRegistry } from "../../../operations/registry.js";
+import "../../../index.js";
+import * as _contractspec_lib_schema0 from "@contractspec/lib.schema";
+import { SchemaModel } from "@contractspec/lib.schema";
+
+//#region src/integrations/meeting-recorder/contracts/transcripts.d.ts
+declare const MeetingRecorderGetTranscript: OperationSpec<SchemaModel<{
+  tenantId: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isOptional: false;
+  };
+  meetingId: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isOptional: false;
+  };
+  connectionId: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isOptional: true;
+  };
+  includeSegments: {
+    type: _contractspec_lib_schema0.FieldType<boolean, boolean>;
+    isOptional: true;
+  };
+  format: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isOptional: true;
+  };
+}>, SchemaModel<{
+  id: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isOptional: false;
+  };
+  meetingId: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isOptional: false;
+  };
+  tenantId: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isOptional: false;
+  };
+  connectionId: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isOptional: false;
+  };
+  externalId: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isOptional: true;
+  };
+  format: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isOptional: true;
+  };
+  text: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isOptional: true;
+  };
+  segments: {
+    type: SchemaModel<{
+      index: {
+        type: _contractspec_lib_schema0.FieldType<number, number>;
+        isOptional: true;
+      };
+      speakerId: {
+        type: _contractspec_lib_schema0.FieldType<string, string>;
+        isOptional: true;
+      };
+      speakerName: {
+        type: _contractspec_lib_schema0.FieldType<string, string>;
+        isOptional: true;
+      };
+      speakerEmail: {
+        type: _contractspec_lib_schema0.FieldType<string, string>;
+        isOptional: true;
+      };
+      text: {
+        type: _contractspec_lib_schema0.FieldType<string, string>;
+        isOptional: false;
+      };
+      startTimeMs: {
+        type: _contractspec_lib_schema0.FieldType<number, number>;
+        isOptional: true;
+      };
+      endTimeMs: {
+        type: _contractspec_lib_schema0.FieldType<number, number>;
+        isOptional: true;
+      };
+      startTime: {
+        type: _contractspec_lib_schema0.FieldType<Date, string>;
+        isOptional: true;
+      };
+      endTime: {
+        type: _contractspec_lib_schema0.FieldType<Date, string>;
+        isOptional: true;
+      };
+      confidence: {
+        type: _contractspec_lib_schema0.FieldType<number, number>;
+        isOptional: true;
+      };
+      metadata: {
+        type: _contractspec_lib_schema0.FieldType<Record<string, unknown>, Record<string, unknown>>;
+        isOptional: true;
+      };
+    }>;
+    isArray: true;
+    isOptional: true;
+  };
+  language: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isOptional: true;
+  };
+  sourceUrl: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isOptional: true;
+  };
+  generatedAt: {
+    type: _contractspec_lib_schema0.FieldType<Date, string>;
+    isOptional: true;
+  };
+  metadata: {
+    type: _contractspec_lib_schema0.FieldType<Record<string, unknown>, Record<string, unknown>>;
+    isOptional: true;
+  };
+  raw: {
+    type: _contractspec_lib_schema0.FieldType<unknown, unknown>;
+    isOptional: true;
+  };
+}>, undefined>;
+declare const MeetingRecorderSyncTranscript: OperationSpec<SchemaModel<{
+  tenantId: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isOptional: false;
+  };
+  meetingId: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isOptional: false;
+  };
+  connectionId: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isOptional: true;
+  };
+  forceRefresh: {
+    type: _contractspec_lib_schema0.FieldType<boolean, boolean>;
+    isOptional: true;
+  };
+  triggerWebhooks: {
+    type: _contractspec_lib_schema0.FieldType<boolean, boolean>;
+    isOptional: true;
+  };
+}>, SchemaModel<{
+  synced: {
+    type: _contractspec_lib_schema0.FieldType<number, number>;
+    isOptional: false;
+  };
+  failed: {
+    type: _contractspec_lib_schema0.FieldType<number, number>;
+    isOptional: false;
+  };
+  errors: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isArray: true;
+    isOptional: true;
+  };
+  nextSyncSuggestedAt: {
+    type: _contractspec_lib_schema0.FieldType<Date, string>;
+    isOptional: true;
+  };
+}>, undefined>;
+declare const meetingRecorderTranscriptContracts: Record<string, AnyOperationSpec>;
+declare function registerMeetingRecorderTranscriptContracts(registry: OperationSpecRegistry): OperationSpecRegistry;
+//#endregion
+export { MeetingRecorderGetTranscript, MeetingRecorderSyncTranscript, meetingRecorderTranscriptContracts, registerMeetingRecorderTranscriptContracts };

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

@@ -0,0 +1,156 @@
+import { defineCommand, defineQuery } from "../../../operations/operation.js";
+import "../../../operations/index.js";
+import { MeetingTranscriptRecord } from "../models.js";
+import { MEETING_RECORDER_TELEMETRY_EVENTS } from "../telemetry.js";
+import { ScalarTypeEnum, SchemaModel } from "@contractspec/lib.schema";
+
+//#region src/integrations/meeting-recorder/contracts/transcripts.ts
+const MeetingRecorderGetTranscriptInput = new SchemaModel({
+	name: "MeetingRecorderGetTranscriptInput",
+	description: "Parameters for fetching a meeting transcript.",
+	fields: {
+		tenantId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: false
+		},
+		meetingId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: false
+		},
+		connectionId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: true
+		},
+		includeSegments: {
+			type: ScalarTypeEnum.Boolean(),
+			isOptional: true
+		},
+		format: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: true
+		}
+	}
+});
+const MeetingRecorderSyncTranscriptInput = new SchemaModel({
+	name: "MeetingRecorderSyncTranscriptInput",
+	description: "Command payload to synchronise meeting transcripts.",
+	fields: {
+		tenantId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: false
+		},
+		meetingId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: false
+		},
+		connectionId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: true
+		},
+		forceRefresh: {
+			type: ScalarTypeEnum.Boolean(),
+			isOptional: true
+		},
+		triggerWebhooks: {
+			type: ScalarTypeEnum.Boolean(),
+			isOptional: true
+		}
+	}
+});
+const MeetingRecorderSyncTranscriptOutput = new SchemaModel({
+	name: "MeetingRecorderSyncTranscriptOutput",
+	description: "Result of a transcript synchronisation run.",
+	fields: {
+		synced: {
+			type: ScalarTypeEnum.Int_unsecure(),
+			isOptional: false
+		},
+		failed: {
+			type: ScalarTypeEnum.Int_unsecure(),
+			isOptional: false
+		},
+		errors: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isArray: true,
+			isOptional: true
+		},
+		nextSyncSuggestedAt: {
+			type: ScalarTypeEnum.DateTime(),
+			isOptional: true
+		}
+	}
+});
+const MeetingRecorderGetTranscript = defineQuery({
+	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" }
+});
+const 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")
+				};
+			}
+		}
+	}
+});
+const meetingRecorderTranscriptContracts = {
+	MeetingRecorderGetTranscript,
+	MeetingRecorderSyncTranscript
+};
+function registerMeetingRecorderTranscriptContracts(registry) {
+	return registry.register(MeetingRecorderGetTranscript).register(MeetingRecorderSyncTranscript);
+}
+
+//#endregion
+export { MeetingRecorderGetTranscript, MeetingRecorderSyncTranscript, meetingRecorderTranscriptContracts, registerMeetingRecorderTranscriptContracts };

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

@@ -0,0 +1,92 @@
+import { AnyOperationSpec, OperationSpec } from "../../../operations/operation.js";
+import "../../../operations/index.js";
+import { OperationSpecRegistry } from "../../../operations/registry.js";
+import "../../../index.js";
+import * as _contractspec_lib_schema0 from "@contractspec/lib.schema";
+import { SchemaModel } from "@contractspec/lib.schema";
+
+//#region src/integrations/meeting-recorder/contracts/webhooks.d.ts
+declare const MeetingRecorderWebhookIngest: OperationSpec<SchemaModel<{
+  tenantId: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isOptional: false;
+  };
+  providerKey: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isOptional: false;
+  };
+  connectionId: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isOptional: true;
+  };
+  webhookId: {
+    type: _contractspec_lib_schema0.FieldType<string, string>;
+    isOptional: true;
+  };
+  headers: {
+    type: _contractspec_lib_schema0.FieldType<unknown, unknown>;
+    isOptional: true;
+  };
+  payload: {
+    type: _contractspec_lib_schema0.FieldType<unknown, unknown>;
+    isOptional: false;
+  };
+  receivedAt: {
+    type: _contractspec_lib_schema0.FieldType<Date, string>;
+    isOptional: true;
+  };
+}>, SchemaModel<{
+  accepted: {
+    type: _contractspec_lib_schema0.FieldType<boolean, boolean>;
+    isOptional: false;
+  };
+  event: {
+    type: SchemaModel<{
+      id: {
+        type: _contractspec_lib_schema0.FieldType<string, string>;
+        isOptional: true;
+      };
+      providerKey: {
+        type: _contractspec_lib_schema0.FieldType<string, string>;
+        isOptional: true;
+      };
+      eventType: {
+        type: _contractspec_lib_schema0.FieldType<string, string>;
+        isOptional: true;
+      };
+      meetingId: {
+        type: _contractspec_lib_schema0.FieldType<string, string>;
+        isOptional: true;
+      };
+      transcriptId: {
+        type: _contractspec_lib_schema0.FieldType<string, string>;
+        isOptional: true;
+      };
+      recordingId: {
+        type: _contractspec_lib_schema0.FieldType<string, string>;
+        isOptional: true;
+      };
+      receivedAt: {
+        type: _contractspec_lib_schema0.FieldType<Date, string>;
+        isOptional: true;
+      };
+      verified: {
+        type: _contractspec_lib_schema0.FieldType<boolean, boolean>;
+        isOptional: true;
+      };
+      payload: {
+        type: _contractspec_lib_schema0.FieldType<unknown, unknown>;
+        isOptional: true;
+      };
+      metadata: {
+        type: _contractspec_lib_schema0.FieldType<Record<string, unknown>, Record<string, unknown>>;
+        isOptional: true;
+      };
+    }>;
+    isOptional: true;
+  };
+}>, undefined>;
+declare const meetingRecorderWebhookContracts: Record<string, AnyOperationSpec>;
+declare function registerMeetingRecorderWebhookContracts(registry: OperationSpecRegistry): OperationSpecRegistry;
+//#endregion
+export { MeetingRecorderWebhookIngest, meetingRecorderWebhookContracts, registerMeetingRecorderWebhookContracts };

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

@@ -0,0 +1,82 @@
+import { defineCommand } from "../../../operations/operation.js";
+import "../../../operations/index.js";
+import { MeetingRecorderWebhookEventRecord } from "../models.js";
+import { ScalarTypeEnum, SchemaModel } from "@contractspec/lib.schema";
+
+//#region src/integrations/meeting-recorder/contracts/webhooks.ts
+const MeetingRecorderWebhookIngestInput = new SchemaModel({
+	name: "MeetingRecorderWebhookIngestInput",
+	description: "Payload for ingesting a meeting recorder webhook event.",
+	fields: {
+		tenantId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: false
+		},
+		providerKey: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		connectionId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: true
+		},
+		webhookId: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: true
+		},
+		headers: {
+			type: ScalarTypeEnum.JSON(),
+			isOptional: true
+		},
+		payload: {
+			type: ScalarTypeEnum.JSON(),
+			isOptional: false
+		},
+		receivedAt: {
+			type: ScalarTypeEnum.DateTime(),
+			isOptional: true
+		}
+	}
+});
+const MeetingRecorderWebhookIngestOutput = new SchemaModel({
+	name: "MeetingRecorderWebhookIngestOutput",
+	description: "Result of processing a meeting recorder webhook.",
+	fields: {
+		accepted: {
+			type: ScalarTypeEnum.Boolean(),
+			isOptional: false
+		},
+		event: {
+			type: MeetingRecorderWebhookEventRecord,
+			isOptional: true
+		}
+	}
+});
+const 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" }
+});
+const meetingRecorderWebhookContracts = { MeetingRecorderWebhookIngest };
+function registerMeetingRecorderWebhookContracts(registry) {
+	return registry.register(MeetingRecorderWebhookIngest);
+}
+
+//#endregion
+export { MeetingRecorderWebhookIngest, meetingRecorderWebhookContracts, registerMeetingRecorderWebhookContracts };

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

@@ -0,0 +1,7 @@
+import { CapabilitySpec } from "../../capabilities/capabilities.js";
+import "../../index.js";
+
+//#region src/integrations/meeting-recorder/meeting-recorder.capability.d.ts
+declare const MeetingRecorderCapability: CapabilitySpec;
+//#endregion
+export { MeetingRecorderCapability };

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

@@ -0,0 +1,21 @@
+import { defineCapability } from "../../capabilities/capabilities.js";
+import { StabilityEnum } from "../../ownership.js";
+import "../../capabilities/index.js";
+
+//#region src/integrations/meeting-recorder/meeting-recorder.capability.ts
+const 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"
+	]
+} });
+
+//#endregion
+export { MeetingRecorderCapability };

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

@@ -0,0 +1,11 @@
+import { FeatureModuleSpec } from "../../features/types.js";
+import "../../index.js";
+
+//#region src/integrations/meeting-recorder/meeting-recorder.feature.d.ts
+/**
+ * Meeting recorder feature module that bundles meeting metadata,
+ * transcript fetch, and webhook ingestion capabilities.
+ */
+declare const MeetingRecorderFeature: FeatureModuleSpec;
+//#endregion
+export { MeetingRecorderFeature };