@xfey/tenso 0.1.130

package/node_modules/@tutti/shared/dist/schemas/internal/platform-integration.js

@@ -0,0 +1,963 @@
+import { Type } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+import { ExternalReferenceDescriptorSchema } from "../api/external-references.js";
+import { PlatformClarificationContentSchema } from "./platform-clarification-content.js";
+import { IdempotencyKeySchema, ClarificationRoundRefSchema, IsoDateTimeStringSchema, MessageIdSchema, RelayAccountRefSchema, RelayProjectRefSchema, } from "../domain/index.js";
+import { MAX_REFERENCE_STAGED_UPLOAD_BYTES, PresignedUploadPutSchema, ReferenceStagedUploadReferenceProperties, RelayUploadProjectionSchema, } from "../api/uploads.js";
+export const PlatformAdapterKeySchema = Type.String({
+    minLength: 1,
+    maxLength: 64,
+    pattern: "^[a-z][a-z0-9_-]*$",
+});
+export const IntegrationOwnedRefSchema = Type.String({
+    minLength: 1,
+    maxLength: 256,
+    pattern: "^[^\\u0000-\\u001f\\u007f]+$",
+});
+export const ExternalObjectRefSchema = Type.String({
+    minLength: 1,
+    maxLength: 512,
+    pattern: "^[^\\u0000-\\u001f\\u007f]+$",
+});
+export const PlatformInstallationLocatorSchema = Type.Object({
+    platform: PlatformAdapterKeySchema,
+    installation_ref: IntegrationOwnedRefSchema,
+}, { additionalProperties: false });
+export const PlatformConversationLocatorSchema = Type.Object({
+    installation: PlatformInstallationLocatorSchema,
+    conversation_ref: ExternalObjectRefSchema,
+    thread_ref: Type.Optional(ExternalObjectRefSchema),
+    parent_message_ref: Type.Optional(ExternalObjectRefSchema),
+    root_message_ref: Type.Optional(ExternalObjectRefSchema),
+}, { additionalProperties: false });
+export const ExternalMessageLocatorSchema = Type.Object({
+    conversation: PlatformConversationLocatorSchema,
+    message_ref: ExternalObjectRefSchema,
+}, { additionalProperties: false });
+export const ExternalSubjectLocatorSchema = Type.Object({
+    installation: PlatformInstallationLocatorSchema,
+    subject_kind: Type.Union([
+        Type.Literal("human"),
+        Type.Literal("bot"),
+        Type.Literal("app"),
+        Type.Literal("system"),
+    ]),
+    subject_ref: ExternalObjectRefSchema,
+}, { additionalProperties: false });
+export const TrustedHumanIntegrationActorContextSchema = Type.Object({
+    kind: Type.Literal("human"),
+    account_ref: RelayAccountRefSchema,
+    display_name: Type.String({ minLength: 1, maxLength: 256 }),
+    membership: Type.Object({
+        relay_project_ref: RelayProjectRefSchema,
+        label: Type.Union([Type.Literal("owner"), Type.Literal("member")]),
+    }, { additionalProperties: false }),
+    channel: Type.Union([
+        Type.Literal("platform_chat"),
+        Type.Literal("platform_h5"),
+        Type.Literal("platform_card_callback"),
+        Type.Literal("platform_document_sync"),
+    ]),
+    external_subject: ExternalSubjectLocatorSchema,
+    binding_ref: IntegrationOwnedRefSchema,
+    verified_at: IsoDateTimeStringSchema,
+}, { additionalProperties: false });
+export const TrustedSystemIntegrationActorContextSchema = Type.Object({
+    kind: Type.Literal("system"),
+    purpose: Type.Union([
+        Type.Literal("live_ingestion"),
+        Type.Literal("history_backfill"),
+        Type.Literal("revision_observation"),
+        Type.Literal("attachment_handoff"),
+        Type.Literal("projection_retry"),
+        Type.Literal("reconciliation"),
+    ]),
+    installation: PlatformInstallationLocatorSchema,
+    binding_ref: Type.Optional(IntegrationOwnedRefSchema),
+    verified_at: IsoDateTimeStringSchema,
+}, { additionalProperties: false });
+export const TrustedDevelopmentBotActorContextSchema = Type.Object({
+    ...TrustedHumanIntegrationActorContextSchema.properties,
+    kind: Type.Literal("bot"),
+    purpose: Type.Literal("development_operator"),
+    channel: Type.Literal("platform_chat"),
+}, { additionalProperties: false });
+export const TrustedIntegrationActorContextSchema = Type.Union([
+    TrustedHumanIntegrationActorContextSchema,
+    TrustedSystemIntegrationActorContextSchema,
+]);
+export const NormalizedConversationAuthorSchema = Type.Object({
+    account_ref: RelayAccountRefSchema,
+    display_name: Type.String({ minLength: 1, maxLength: 256 }),
+    external_subject: ExternalSubjectLocatorSchema,
+}, { additionalProperties: false });
+export const PreIdentityConversationAuthorSchema = Type.Object({
+    external_subject: ExternalSubjectLocatorSchema,
+}, { additionalProperties: false });
+export const NormalizedConversationMentionSchema = Type.Object({
+    external_subject: ExternalSubjectLocatorSchema,
+    account_ref: Type.Optional(RelayAccountRefSchema),
+    display_text: Type.Optional(Type.String({ minLength: 1, maxLength: 256 })),
+    target_kind: Type.Union([Type.Literal("person"), Type.Literal("tutti")]),
+}, { additionalProperties: false });
+export const NormalizedConversationContentSchema = Type.Union([
+    Type.Object({
+        kind: Type.Literal("text"),
+        text: Type.String({ minLength: 1, maxLength: 100_000 }),
+        mentions: Type.Array(NormalizedConversationMentionSchema, { maxItems: 128 }),
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("post"),
+        text: Type.String({ minLength: 1, maxLength: 100_000 }),
+        mentions: Type.Array(NormalizedConversationMentionSchema, { maxItems: 128 }),
+    }, { additionalProperties: false }),
+]);
+export const ExternalAttachmentDescriptorSchema = Type.Object({
+    attachment_ref: ExternalObjectRefSchema,
+    attachment_kind: Type.Union([
+        Type.Literal("file"),
+        Type.Literal("image"),
+        Type.Literal("audio"),
+        Type.Literal("video"),
+        Type.Literal("other"),
+    ]),
+    file_name: Type.Optional(Type.String({ minLength: 1, maxLength: 512 })),
+    media_type: Type.Optional(Type.String({ minLength: 1, maxLength: 255 })),
+    declared_size_bytes: Type.Optional(Type.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER })),
+}, { additionalProperties: false });
+export const VerifiedAttachmentContentMetadataSchema = Type.Object({
+    attachment: ExternalAttachmentDescriptorSchema,
+    size_bytes: Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER }),
+    sha256: Type.String({ pattern: "^sha256:[0-9a-f]{64}$" }),
+    media_type: Type.String({ minLength: 1, maxLength: 255 }),
+    verified_at: IsoDateTimeStringSchema,
+}, { additionalProperties: false });
+export const PreIdentityReferenceAttachmentSourceSchema = Type.Object({
+    locator: ExternalMessageLocatorSchema,
+    author: PreIdentityConversationAuthorSchema,
+    attachment: ExternalAttachmentDescriptorSchema,
+    external_created_at: IsoDateTimeStringSchema,
+    observed_at: IsoDateTimeStringSchema,
+    adapter_version: Type.String({ minLength: 1, maxLength: 128 }),
+}, { additionalProperties: false });
+export const NormalizedConversationSourceSchema = Type.Object({
+    external_references: Type.Optional(Type.Array(ExternalReferenceDescriptorSchema, { minItems: 1, maxItems: 16 })),
+    locator: ExternalMessageLocatorSchema,
+    revision_ref: ExternalObjectRefSchema,
+    author: NormalizedConversationAuthorSchema,
+    content: NormalizedConversationContentSchema,
+    attachments: Type.Array(ExternalAttachmentDescriptorSchema, { maxItems: 64 }),
+    external_created_at: IsoDateTimeStringSchema,
+    observed_at: IsoDateTimeStringSchema,
+    adapter_version: Type.String({ minLength: 1, maxLength: 128 }),
+}, { additionalProperties: false });
+export const PreIdentityNormalizedConversationSourceSchema = Type.Object({
+    external_references: Type.Optional(Type.Array(ExternalReferenceDescriptorSchema, { minItems: 1, maxItems: 16 })),
+    locator: ExternalMessageLocatorSchema,
+    revision_ref: ExternalObjectRefSchema,
+    author: PreIdentityConversationAuthorSchema,
+    content: NormalizedConversationContentSchema,
+    attachments: Type.Array(ExternalAttachmentDescriptorSchema, { maxItems: 64 }),
+    external_created_at: IsoDateTimeStringSchema,
+    observed_at: IsoDateTimeStringSchema,
+    adapter_version: Type.String({ minLength: 1, maxLength: 128 }),
+}, { additionalProperties: false });
+export const ExternalConversationRevisionObservationSchema = Type.Union([
+    Type.Object({
+        kind: Type.Literal("edited"),
+        locator: ExternalMessageLocatorSchema,
+        revision_ref: ExternalObjectRefSchema,
+        content: NormalizedConversationContentSchema,
+        attachments: Type.Array(ExternalAttachmentDescriptorSchema, { maxItems: 64 }),
+        external_updated_at: IsoDateTimeStringSchema,
+        observed_at: IsoDateTimeStringSchema,
+        adapter_version: Type.String({ minLength: 1, maxLength: 128 }),
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("deleted"),
+        locator: ExternalMessageLocatorSchema,
+        revision_ref: ExternalObjectRefSchema,
+        external_updated_at: IsoDateTimeStringSchema,
+        observed_at: IsoDateTimeStringSchema,
+        adapter_version: Type.String({ minLength: 1, maxLength: 128 }),
+    }, { additionalProperties: false }),
+]);
+export const InboundIntegrationEventReceiptSchema = Type.Object({
+    receipt_key: IntegrationOwnedRefSchema,
+    installation: PlatformInstallationLocatorSchema,
+    external_event_ref: ExternalObjectRefSchema,
+    event_kind: Type.Union([
+        Type.Literal("conversation_source"),
+        Type.Literal("conversation_revision"),
+        Type.Literal("attachment"),
+        Type.Literal("card_action"),
+    ]),
+    received_at: IsoDateTimeStringSchema,
+    attempt: Type.Integer({ minimum: 1, maximum: 1_000_000 }),
+}, { additionalProperties: false });
+export const ConversationSourceIngestionEnvelopeSchema = Type.Object({
+    kind: Type.Literal("conversation_source"),
+    receipt: InboundIntegrationEventReceiptSchema,
+    actor: TrustedSystemIntegrationActorContextSchema,
+    source: NormalizedConversationSourceSchema,
+}, { additionalProperties: false });
+export const ConversationRevisionIngestionEnvelopeSchema = Type.Object({
+    kind: Type.Literal("conversation_revision"),
+    receipt: InboundIntegrationEventReceiptSchema,
+    actor: TrustedSystemIntegrationActorContextSchema,
+    observation: ExternalConversationRevisionObservationSchema,
+}, { additionalProperties: false });
+export const ConversationIngestionEnvelopeSchema = Type.Union([
+    ConversationSourceIngestionEnvelopeSchema,
+    ConversationRevisionIngestionEnvelopeSchema,
+]);
+export const IntegrationDeliveryDispositionSchema = Type.Union([
+    Type.Object({ kind: Type.Literal("created"), message_id: MessageIdSchema }, { additionalProperties: false }),
+    Type.Object({ kind: Type.Literal("duplicate"), message_id: MessageIdSchema }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("revision_recorded"),
+        message_id: MessageIdSchema,
+        revision_ref: ExternalObjectRefSchema,
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("stale_revision"),
+        message_id: MessageIdSchema,
+        revision_ref: ExternalObjectRefSchema,
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("unsupported"),
+        reason_code: Type.String({ minLength: 1, maxLength: 128 }),
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("unauthorized"),
+        reason_code: Type.Optional(Type.String({ minLength: 1, maxLength: 128 })),
+    }, { additionalProperties: false }),
+    Type.Object({ kind: Type.Literal("binding_missing") }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("host_unavailable"),
+        retryable: Type.Literal(true),
+        reason_code: Type.Optional(Type.String({ minLength: 1, maxLength: 128 })),
+        retry_after: Type.Optional(IsoDateTimeStringSchema),
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("host_incompatible"),
+        retryable: Type.Literal(true),
+        reason_code: Type.Union([
+            Type.Literal("integration_source_ingestion_unsupported"),
+            Type.Literal("integration_attachment_ingestion_unsupported"),
+            Type.Literal("integration_managed_reference_ingestion_unsupported"),
+            Type.Literal("integration_clarification_unsupported"),
+        ]),
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("invalid"),
+        reason_code: Type.String({ minLength: 1, maxLength: 128 }),
+    }, { additionalProperties: false }),
+]);
+export const IntegrationConversationSourceDeliveryRequestSchema = Type.Object({
+    protocol_version: Type.Union([Type.Literal(2), Type.Literal(3)]),
+    command_id: IdempotencyKeySchema,
+    relay_project_ref: RelayProjectRefSchema,
+    binding_ref: IntegrationOwnedRefSchema,
+    receipt: InboundIntegrationEventReceiptSchema,
+    source: PreIdentityNormalizedConversationSourceSchema,
+    clarification_round_ref: Type.Optional(ClarificationRoundRefSchema),
+}, { additionalProperties: false });
+export const IntegrationReferenceAttachmentStageRequestSchema = Type.Object({
+    protocol_version: Type.Literal(1),
+    command_id: IdempotencyKeySchema,
+    relay_project_ref: RelayProjectRefSchema,
+    binding_ref: IntegrationOwnedRefSchema,
+    receipt: InboundIntegrationEventReceiptSchema,
+    source: PreIdentityReferenceAttachmentSourceSchema,
+    content: VerifiedAttachmentContentMetadataSchema,
+}, { additionalProperties: false });
+export const IntegrationReferenceAttachmentStageDispositionSchema = Type.Union([
+    Type.Object({
+        kind: Type.Literal("staged"),
+        upload: RelayUploadProjectionSchema,
+        put: PresignedUploadPutSchema,
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("unauthorized"),
+        reason_code: Type.String({ minLength: 1, maxLength: 128 }),
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("invalid"),
+        reason_code: Type.String({ minLength: 1, maxLength: 128 }),
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("unavailable"),
+        retryable: Type.Literal(true),
+        reason_code: Type.String({ minLength: 1, maxLength: 128 }),
+    }, { additionalProperties: false }),
+]);
+export const IntegrationReferenceAttachmentStageResponseSchema = Type.Object({
+    protocol_version: Type.Literal(1),
+    disposition: IntegrationReferenceAttachmentStageDispositionSchema,
+}, { additionalProperties: false });
+export const FEISHU_CONVERSATION_PAIRING_CODE_LENGTH = 20;
+export const FeishuConversationPairingCodeSchema = Type.String({
+    minLength: FEISHU_CONVERSATION_PAIRING_CODE_LENGTH,
+    maxLength: FEISHU_CONVERSATION_PAIRING_CODE_LENGTH,
+    pattern: "^[A-Z2-7]+$",
+});
+export const FeishuSetupProjectionSchema = Type.Union([
+    Type.Object({ state: Type.Literal("account_handoff_required") }, { additionalProperties: false }),
+    Type.Object({
+        state: Type.Literal("pairing_required"),
+        pairing_code: FeishuConversationPairingCodeSchema,
+        command: Type.String({ minLength: 1, maxLength: 128 }),
+        expires_at: IsoDateTimeStringSchema,
+        visibility: Type.Literal("visible_once"),
+    }, { additionalProperties: false }),
+    Type.Object({
+        state: Type.Literal("pairing_required"),
+        expires_at: Type.Optional(IsoDateTimeStringSchema),
+        visibility: Type.Literal("not_recoverable"),
+    }, { additionalProperties: false }),
+    Type.Object({ state: Type.Literal("connected") }, { additionalProperties: false }),
+]);
+export const IntegrationConversationBindingRequestSchema = Type.Object({
+    protocol_version: Type.Literal(1),
+    pairing_code: FeishuConversationPairingCodeSchema,
+    binding_ref: IntegrationOwnedRefSchema,
+    installation: PlatformInstallationLocatorSchema,
+    conversation_ref: ExternalObjectRefSchema,
+    external_subject: ExternalSubjectLocatorSchema,
+    observed_at: IsoDateTimeStringSchema,
+}, { additionalProperties: false });
+export const IntegrationConversationBindingDispositionSchema = Type.Union([
+    Type.Object({
+        kind: Type.Literal("bound"),
+        relay_project_ref: RelayProjectRefSchema,
+        project_display_name: Type.String({ minLength: 1, maxLength: 256 }),
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("duplicate"),
+        relay_project_ref: RelayProjectRefSchema,
+        project_display_name: Type.String({ minLength: 1, maxLength: 256 }),
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("invalid"),
+        reason_code: Type.String({ minLength: 1, maxLength: 128 }),
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("unauthorized"),
+        reason_code: Type.String({ minLength: 1, maxLength: 128 }),
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("conflict"),
+        reason_code: Type.String({ minLength: 1, maxLength: 128 }),
+    }, { additionalProperties: false }),
+]);
+export const IntegrationConversationBindingResponseSchema = Type.Object({
+    protocol_version: Type.Literal(1),
+    disposition: IntegrationConversationBindingDispositionSchema,
+}, { additionalProperties: false });
+export const INTEGRATION_CONVERSATION_SOURCE_TUNNEL_PATH = "/internal/integration/v1/conversation-sources";
+export const INTEGRATION_REFERENCE_ATTACHMENT_TUNNEL_PATH = "/internal/integration/v1/reference-attachments";
+export const INTEGRATION_MANAGED_REFERENCE_TUNNEL_PATH = "/internal/integration/v1/managed-references";
+export const ManagedReferenceSourceSchema = Type.Object({
+    source_ref: IntegrationOwnedRefSchema,
+    adapter_key: Type.Literal("feishu_docx"),
+    installation: PlatformInstallationLocatorSchema,
+    external_subject: ExternalSubjectLocatorSchema,
+    reference_path: Type.String({ minLength: 1, maxLength: 1_024 }),
+}, { additionalProperties: false });
+export const ManagedReferenceContentMetadataSchema = Type.Object({
+    size_bytes: Type.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
+    sha256: Type.String({ pattern: "^sha256:[0-9a-f]{64}$" }),
+    media_type: Type.Literal("text/plain; charset=utf-8"),
+}, { additionalProperties: false });
+export const IntegrationManagedReferenceStageRequestSchema = Type.Object({
+    protocol_version: Type.Literal(1),
+    command_id: IdempotencyKeySchema,
+    operation_ref: IntegrationOwnedRefSchema,
+    relay_project_ref: RelayProjectRefSchema,
+    binding_ref: IntegrationOwnedRefSchema,
+    source: ManagedReferenceSourceSchema,
+    remote_revision_ref: ExternalObjectRefSchema,
+    expected_host_blob_oid: Type.Optional(Type.String({ pattern: "^[0-9a-f]{40,64}$" })),
+    content: ManagedReferenceContentMetadataSchema,
+}, { additionalProperties: false });
+export const IntegrationManagedReferenceStageDispositionSchema = IntegrationReferenceAttachmentStageDispositionSchema;
+export const IntegrationManagedReferenceStageResponseSchema = Type.Object({
+    protocol_version: Type.Literal(1),
+    disposition: IntegrationManagedReferenceStageDispositionSchema,
+}, { additionalProperties: false });
+export const IntegrationManagedReferenceDeliveryRequestSchema = Type.Object({
+    protocol_version: Type.Literal(1),
+    command_id: IdempotencyKeySchema,
+    operation_ref: IntegrationOwnedRefSchema,
+    relay_project_ref: RelayProjectRefSchema,
+    binding_ref: IntegrationOwnedRefSchema,
+    source: ManagedReferenceSourceSchema,
+    remote_revision_ref: ExternalObjectRefSchema,
+    expected_host_blob_oid: Type.Optional(Type.String({ pattern: "^[0-9a-f]{40,64}$" })),
+    content: ManagedReferenceContentMetadataSchema,
+    staged_upload: Type.Object(ReferenceStagedUploadReferenceProperties, {
+        additionalProperties: false,
+    }),
+}, { additionalProperties: false });
+export const TrustedManagedReferenceIngestionCommandSchema = Type.Object({
+    protocol_version: Type.Literal(1),
+    command_id: IdempotencyKeySchema,
+    operation_ref: IntegrationOwnedRefSchema,
+    relay_project_ref: RelayProjectRefSchema,
+    binding_ref: IntegrationOwnedRefSchema,
+    source: ManagedReferenceSourceSchema,
+    remote_revision_ref: ExternalObjectRefSchema,
+    expected_host_blob_oid: Type.Optional(Type.String({ pattern: "^[0-9a-f]{40,64}$" })),
+    content: ManagedReferenceContentMetadataSchema,
+    staged_upload: Type.Object(ReferenceStagedUploadReferenceProperties, {
+        additionalProperties: false,
+    }),
+    actor: TrustedHumanIntegrationActorContextSchema,
+}, { additionalProperties: false });
+export const IntegrationManagedReferenceDispositionSchema = Type.Union([
+    Type.Object({
+        kind: Type.Union([
+            Type.Literal("created"),
+            Type.Literal("updated"),
+            Type.Literal("unchanged"),
+        ]),
+        current_blob_oid: Type.String({ pattern: "^[0-9a-f]{40,64}$" }),
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("duplicate"),
+        outcome: Type.Union([
+            Type.Literal("created"),
+            Type.Literal("updated"),
+            Type.Literal("unchanged"),
+        ]),
+        current_blob_oid: Type.String({ pattern: "^[0-9a-f]{40,64}$" }),
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("host_unavailable"),
+        retryable: Type.Literal(true),
+        reason_code: Type.String({ minLength: 1, maxLength: 128 }),
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("host_incompatible"),
+        retryable: Type.Literal(true),
+        reason_code: Type.Literal("integration_managed_reference_ingestion_unsupported"),
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Union([
+            Type.Literal("invalid"),
+            Type.Literal("unauthorized"),
+            Type.Literal("conflict"),
+        ]),
+        reason_code: Type.String({ minLength: 1, maxLength: 128 }),
+    }, { additionalProperties: false }),
+]);
+export const IntegrationManagedReferenceDeliveryResponseSchema = Type.Object({
+    protocol_version: Type.Literal(1),
+    disposition: IntegrationManagedReferenceDispositionSchema,
+}, { additionalProperties: false });
+export const TrustedConversationSourceIngestionCommandSchema = Type.Object({
+    protocol_version: Type.Literal(1),
+    command_id: IdempotencyKeySchema,
+    relay_project_ref: RelayProjectRefSchema,
+    binding_ref: IntegrationOwnedRefSchema,
+    receipt: InboundIntegrationEventReceiptSchema,
+    actor: Type.Union([
+        TrustedHumanIntegrationActorContextSchema,
+        TrustedDevelopmentBotActorContextSchema,
+    ]),
+    source: NormalizedConversationSourceSchema,
+    clarification_round_ref: Type.Optional(ClarificationRoundRefSchema),
+}, { additionalProperties: false });
+export const IntegrationReferenceAttachmentDeliveryRequestSchema = Type.Object({
+    protocol_version: Type.Literal(1),
+    command_id: IdempotencyKeySchema,
+    relay_project_ref: RelayProjectRefSchema,
+    binding_ref: IntegrationOwnedRefSchema,
+    receipt: InboundIntegrationEventReceiptSchema,
+    source: PreIdentityReferenceAttachmentSourceSchema,
+    staged_upload: Type.Object(ReferenceStagedUploadReferenceProperties, {
+        additionalProperties: false,
+    }),
+}, { additionalProperties: false });
+export const TrustedReferenceAttachmentIngestionCommandSchema = Type.Object({
+    protocol_version: Type.Literal(1),
+    command_id: IdempotencyKeySchema,
+    relay_project_ref: RelayProjectRefSchema,
+    binding_ref: IntegrationOwnedRefSchema,
+    receipt: InboundIntegrationEventReceiptSchema,
+    actor: TrustedHumanIntegrationActorContextSchema,
+    source: PreIdentityReferenceAttachmentSourceSchema,
+    staged_upload: Type.Object(ReferenceStagedUploadReferenceProperties, {
+        additionalProperties: false,
+    }),
+}, { additionalProperties: false });
+export const IntegrationDeliveryTunnelMetadataSchema = Type.Union([
+    Type.Object({
+        protocol_version: Type.Literal(1),
+        relay_project_ref: RelayProjectRefSchema,
+        installation: PlatformInstallationLocatorSchema,
+        binding_ref: IntegrationOwnedRefSchema,
+        receipt_key: IntegrationOwnedRefSchema,
+        verified_at: IsoDateTimeStringSchema,
+    }, { additionalProperties: false }),
+    Type.Object({
+        protocol_version: Type.Literal(1),
+        relay_project_ref: RelayProjectRefSchema,
+        installation: PlatformInstallationLocatorSchema,
+        binding_ref: IntegrationOwnedRefSchema,
+        operation_ref: IntegrationOwnedRefSchema,
+        verified_at: IsoDateTimeStringSchema,
+    }, { additionalProperties: false }),
+]);
+export const IntegrationConversationSourceDeliveryResponseSchema = Type.Object({
+    protocol_version: Type.Literal(1),
+    disposition: IntegrationDeliveryDispositionSchema,
+}, { additionalProperties: false });
+const PlatformOutboundTextContentSchema = Type.Object({
+    kind: Type.Literal("text"),
+    text: Type.String({ minLength: 1, maxLength: 4_000 }),
+    clarification_round_ref: Type.Optional(ClarificationRoundRefSchema),
+}, { additionalProperties: false });
+export const PlatformApprovalCardRevisionSchema = Type.String({
+    minLength: 1,
+    maxLength: 128,
+    pattern: "^cardrev_[0-9a-f]{32}$",
+});
+export const PlatformApprovalDecisionOptionSchema = Type.Object({
+    decision_id: Type.String({ minLength: 1, maxLength: 256 }),
+    kind: Type.Union([
+        Type.Literal("allow_once"),
+        Type.Literal("allow_session"),
+        Type.Literal("deny"),
+        Type.Literal("cancel"),
+    ]),
+    label: Type.String({ minLength: 1, maxLength: 256 }),
+    tone: Type.Union([Type.Literal("primary"), Type.Literal("neutral"), Type.Literal("danger")]),
+}, { additionalProperties: false });
+export const PlatformOutboundApprovalRequestContentSchema = Type.Object({
+    kind: Type.Literal("approval_request"),
+    approval_id: Type.String({ minLength: 1, maxLength: 256 }),
+    card_revision: PlatformApprovalCardRevisionSchema,
+    title: Type.String({ minLength: 1, maxLength: 512 }),
+    summary: Type.String({ minLength: 1, maxLength: 4_000 }),
+    reason: Type.Optional(Type.String({ minLength: 1, maxLength: 2_000 })),
+    requested_at: IsoDateTimeStringSchema,
+    expires_at: Type.Optional(IsoDateTimeStringSchema),
+    decisions: Type.Array(PlatformApprovalDecisionOptionSchema, {
+        minItems: 1,
+        maxItems: 8,
+    }),
+}, { additionalProperties: false });
+export const PlatformOutboundContentSchema = Type.Union([
+    PlatformOutboundTextContentSchema,
+    PlatformOutboundApprovalRequestContentSchema,
+    PlatformClarificationContentSchema,
+]);
+export const PlatformOutboundEventSchema = Type.Object({
+    kind: Type.Union([
+        Type.Literal("chat_response"),
+        Type.Literal("needs_input"),
+        Type.Literal("task_completed"),
+        Type.Literal("task_failed"),
+    ]),
+    event_key: ExternalObjectRefSchema,
+    subject: Type.Object({
+        kind: Type.Union([
+            Type.Literal("message"),
+            Type.Literal("clarification_round"),
+            Type.Literal("approval_request"),
+            Type.Literal("task_result"),
+        ]),
+        ref: ExternalObjectRefSchema,
+    }, { additionalProperties: false }),
+    target: Type.Object({
+        kind: Type.Union([Type.Literal("project"), Type.Literal("work")]),
+    }, { additionalProperties: false }),
+}, { additionalProperties: false });
+const PlatformOutboundIntentFields = {
+    protocol_version: Type.Literal(1),
+    intent_ref: IdempotencyKeySchema,
+    relay_project_ref: RelayProjectRefSchema,
+    installation: PlatformInstallationLocatorSchema,
+    binding_ref: IntegrationOwnedRefSchema,
+    canonical_message_ref: Type.Optional(MessageIdSchema),
+    trigger_message_ref: Type.Optional(MessageIdSchema),
+    content: PlatformOutboundContentSchema,
+    event: Type.Optional(PlatformOutboundEventSchema),
+    created_at: IsoDateTimeStringSchema,
+    attempt: Type.Integer({ minimum: 1, maximum: 1_000_000 }),
+};
+export const PlatformOutboundIntentSchema = Type.Object(PlatformOutboundIntentFields, {
+    additionalProperties: false,
+});
+export const RelayAuthorizedPlatformOutboundIntentSchema = Type.Object({
+    ...PlatformOutboundIntentFields,
+    conversation_ref: ExternalObjectRefSchema,
+}, { additionalProperties: false });
+// Compatibility aliases for the original text-only contract name. The schema now
+// carries either text or a structured approval request.
+export const PlatformOutboundTextIntentSchema = PlatformOutboundIntentSchema;
+export const RelayAuthorizedPlatformOutboundTextIntentSchema = RelayAuthorizedPlatformOutboundIntentSchema;
+export const PlatformCardCallbackSchema = Type.Object({
+    conversation_ref: ExternalObjectRefSchema,
+    message_ref: ExternalObjectRefSchema,
+    action_ref: IntegrationOwnedRefSchema,
+    card_revision: PlatformApprovalCardRevisionSchema,
+    external_subject: ExternalSubjectLocatorSchema,
+}, { additionalProperties: false });
+export const IntegrationApprovalDecisionDeliveryRequestSchema = Type.Object({
+    protocol_version: Type.Literal(1),
+    command_id: IdempotencyKeySchema,
+    relay_project_ref: RelayProjectRefSchema,
+    binding_ref: IntegrationOwnedRefSchema,
+    receipt: InboundIntegrationEventReceiptSchema,
+    callback: PlatformCardCallbackSchema,
+    approval_id: Type.String({ minLength: 1, maxLength: 256 }),
+    decision_id: Type.String({ minLength: 1, maxLength: 256 }),
+}, { additionalProperties: false });
+export const TrustedApprovalDecisionCommandSchema = Type.Object({
+    protocol_version: Type.Literal(1),
+    command_id: IdempotencyKeySchema,
+    relay_project_ref: RelayProjectRefSchema,
+    binding_ref: IntegrationOwnedRefSchema,
+    receipt: InboundIntegrationEventReceiptSchema,
+    actor: TrustedHumanIntegrationActorContextSchema,
+    callback: Type.Object({
+        message_ref: ExternalObjectRefSchema,
+        action_ref: IntegrationOwnedRefSchema,
+        card_revision: PlatformApprovalCardRevisionSchema,
+    }, { additionalProperties: false }),
+    approval_id: Type.String({ minLength: 1, maxLength: 256 }),
+    decision_id: Type.String({ minLength: 1, maxLength: 256 }),
+}, { additionalProperties: false });
+export const IntegrationApprovalDecisionDispositionSchema = Type.Union([
+    Type.Object({ kind: Type.Literal("accepted") }, { additionalProperties: false }),
+    Type.Object({ kind: Type.Literal("stale_approval") }, { additionalProperties: false }),
+    Type.Object({ kind: Type.Literal("decision_unavailable") }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("interrupted"),
+        retry_with_new_command_id: Type.Boolean(),
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("unauthorized"),
+        reason_code: Type.String({ minLength: 1, maxLength: 128 }),
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("invalid"),
+        reason_code: Type.String({ minLength: 1, maxLength: 128 }),
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("host_unavailable"),
+        retryable: Type.Literal(true),
+        reason_code: Type.String({ minLength: 1, maxLength: 128 }),
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("host_incompatible"),
+        retryable: Type.Literal(true),
+        reason_code: Type.Literal("integration_approval_decision_unsupported"),
+    }, { additionalProperties: false }),
+]);
+export const IntegrationApprovalDecisionDeliveryResponseSchema = Type.Object({
+    protocol_version: Type.Literal(1),
+    disposition: IntegrationApprovalDecisionDispositionSchema,
+}, { additionalProperties: false });
+export const INTEGRATION_APPROVAL_DECISION_TUNNEL_PATH = "/internal/integration/v1/approval-decisions";
+export const IntegrationOutboundClaimRequestSchema = Type.Object({
+    protocol_version: Type.Literal(1),
+    installation: PlatformInstallationLocatorSchema,
+}, { additionalProperties: false });
+export const IntegrationOutboundClaimResponseSchema = Type.Union([
+    Type.Object({
+        protocol_version: Type.Literal(1),
+        disposition: Type.Object({
+            kind: Type.Literal("idle"),
+            retry_after_ms: Type.Integer({ minimum: 100, maximum: 60_000 }),
+        }, { additionalProperties: false }),
+    }, { additionalProperties: false }),
+    Type.Object({
+        protocol_version: Type.Literal(1),
+        disposition: Type.Object({
+            kind: Type.Literal("claimed"),
+            claim_ref: IntegrationOwnedRefSchema,
+            claim_expires_at: IsoDateTimeStringSchema,
+            intent: RelayAuthorizedPlatformOutboundIntentSchema,
+        }, { additionalProperties: false }),
+    }, { additionalProperties: false }),
+]);
+export const IntegrationOutboundAckDispositionSchema = Type.Union([
+    Type.Object({
+        kind: Type.Literal("accepted"),
+        delivery_ref: IntegrationOwnedRefSchema,
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("duplicate"),
+        delivery_ref: IntegrationOwnedRefSchema,
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("rejected"),
+        reason_code: Type.String({ minLength: 1, maxLength: 128 }),
+    }, { additionalProperties: false }),
+]);
+export const IntegrationOutboundAckRequestSchema = Type.Object({
+    protocol_version: Type.Literal(1),
+    installation: PlatformInstallationLocatorSchema,
+    claim_ref: IntegrationOwnedRefSchema,
+    intent_ref: IdempotencyKeySchema,
+    disposition: IntegrationOutboundAckDispositionSchema,
+}, { additionalProperties: false });
+export const IntegrationOutboundAckResponseSchema = Type.Object({
+    protocol_version: Type.Literal(1),
+    disposition: Type.Union([
+        Type.Object({ kind: Type.Literal("acknowledged") }, { additionalProperties: false }),
+        Type.Object({
+            kind: Type.Literal("stale"),
+            reason_code: Type.String({ minLength: 1, maxLength: 128 }),
+        }, { additionalProperties: false }),
+    ]),
+}, { additionalProperties: false });
+export const PlatformOutboundHandoffDispositionSchema = Type.Union([
+    Type.Object({
+        kind: Type.Literal("accepted"),
+        delivery_ref: IntegrationOwnedRefSchema,
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("duplicate"),
+        delivery_ref: IntegrationOwnedRefSchema,
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("unavailable"),
+        retryable: Type.Literal(true),
+        reason_code: Type.String({ minLength: 1, maxLength: 128 }),
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Union([
+            Type.Literal("invalid"),
+            Type.Literal("unauthorized"),
+            Type.Literal("unsupported"),
+        ]),
+        reason_code: Type.String({ minLength: 1, maxLength: 128 }),
+    }, { additionalProperties: false }),
+]);
+export const PlatformOutboundHandoffResponseSchema = Type.Object({
+    protocol_version: Type.Literal(1),
+    disposition: PlatformOutboundHandoffDispositionSchema,
+}, { additionalProperties: false });
+function sameInstallation(left, right) {
+    return left.platform === right.platform && left.installation_ref === right.installation_ref;
+}
+export function isConversationIngestionEnvelope(value) {
+    if (!Value.Check(ConversationIngestionEnvelopeSchema, value)) {
+        return false;
+    }
+    const envelope = value;
+    const locatorInstallation = envelope.kind === "conversation_source"
+        ? envelope.source.locator.conversation.installation
+        : envelope.observation.locator.conversation.installation;
+    if (!sameInstallation(envelope.receipt.installation, envelope.actor.installation) ||
+        !sameInstallation(envelope.receipt.installation, locatorInstallation)) {
+        return false;
+    }
+    return envelope.kind === "conversation_source"
+        ? envelope.actor.purpose === "live_ingestion" || envelope.actor.purpose === "history_backfill"
+        : envelope.actor.purpose === "revision_observation" ||
+            envelope.actor.purpose === "history_backfill";
+}
+function sameExternalSubject(left, right) {
+    return (left.subject_kind === right.subject_kind &&
+        left.subject_ref === right.subject_ref &&
+        sameInstallation(left.installation, right.installation));
+}
+export function isIntegrationConversationSourceDeliveryRequest(value) {
+    if (!Value.Check(IntegrationConversationSourceDeliveryRequestSchema, value)) {
+        return false;
+    }
+    const request = value;
+    const sourceInstallation = request.source.locator.conversation.installation;
+    const sourceSubject = request.source.author.external_subject;
+    return ((request.clarification_round_ref === undefined
+        ? request.protocol_version === 2
+        : request.protocol_version === 3 &&
+            (request.source.locator.conversation.parent_message_ref !== undefined ||
+                request.source.locator.conversation.root_message_ref !== undefined)) &&
+        request.receipt.event_kind === "conversation_source" &&
+        (sourceSubject.subject_kind === "human" || sourceSubject.subject_kind === "bot") &&
+        sameInstallation(request.receipt.installation, sourceInstallation) &&
+        sameInstallation(request.receipt.installation, sourceSubject.installation));
+}
+function sameAttachment(left, right) {
+    return (left.attachment_ref === right.attachment_ref &&
+        left.attachment_kind === right.attachment_kind &&
+        left.file_name === right.file_name &&
+        left.media_type === right.media_type);
+}
+function validPreIdentityReferenceAttachmentAuthority(value) {
+    return (value.receipt.event_kind === "attachment" &&
+        value.source.author.external_subject.subject_kind === "human" &&
+        sameInstallation(value.receipt.installation, value.source.locator.conversation.installation) &&
+        sameInstallation(value.receipt.installation, value.source.author.external_subject.installation));
+}
+export function isIntegrationReferenceAttachmentStageRequest(value) {
+    return (Value.Check(IntegrationReferenceAttachmentStageRequestSchema, value) &&
+        validPreIdentityReferenceAttachmentAuthority(value) &&
+        sameAttachment(value.source.attachment, value.content.attachment) &&
+        value.content.attachment.file_name !== undefined);
+}
+export function isIntegrationReferenceAttachmentStageResponse(value) {
+    return Value.Check(IntegrationReferenceAttachmentStageResponseSchema, value);
+}
+export function isIntegrationReferenceAttachmentDeliveryRequest(value) {
+    return (Value.Check(IntegrationReferenceAttachmentDeliveryRequestSchema, value) &&
+        validPreIdentityReferenceAttachmentAuthority(value) &&
+        value.source.attachment.file_name === value.staged_upload.file_name &&
+        value.source.attachment.media_type === value.staged_upload.media_type);
+}
+function validManagedReferenceSource(value) {
+    return (value.source_ref.startsWith("managed_ref_") &&
+        value.installation.platform === "feishu" &&
+        value.external_subject.subject_kind === "human" &&
+        sameInstallation(value.installation, value.external_subject.installation) &&
+        value.reference_path.startsWith("docs/reference/") &&
+        !value.reference_path.includes("\\") &&
+        !value.reference_path
+            .split("/")
+            .some((segment) => segment.length === 0 || segment === "." || segment === ".."));
+}
+function validManagedReferenceContent(value) {
+    return value.size_bytes <= MAX_REFERENCE_STAGED_UPLOAD_BYTES;
+}
+function sameManagedReferenceStageContent(value) {
+    return (value.content.size_bytes === value.staged_upload.size_bytes &&
+        value.content.sha256 === value.staged_upload.sha256 &&
+        value.content.media_type === value.staged_upload.media_type &&
+        value.staged_upload.file_name === value.source.reference_path.split("/").at(-1));
+}
+export function isIntegrationManagedReferenceStageRequest(value) {
+    return (Value.Check(IntegrationManagedReferenceStageRequestSchema, value) &&
+        validManagedReferenceSource(value.source) &&
+        validManagedReferenceContent(value.content));
+}
+export function isIntegrationManagedReferenceStageResponse(value) {
+    return Value.Check(IntegrationManagedReferenceStageResponseSchema, value);
+}
+export function isIntegrationManagedReferenceDeliveryRequest(value) {
+    return (Value.Check(IntegrationManagedReferenceDeliveryRequestSchema, value) &&
+        validManagedReferenceSource(value.source) &&
+        validManagedReferenceContent(value.content) &&
+        sameManagedReferenceStageContent(value));
+}
+export function isTrustedManagedReferenceIngestionCommand(value) {
+    if (!Value.Check(TrustedManagedReferenceIngestionCommandSchema, value)) {
+        return false;
+    }
+    return (validManagedReferenceSource(value.source) &&
+        validManagedReferenceContent(value.content) &&
+        sameManagedReferenceStageContent(value) &&
+        value.actor.channel === "platform_document_sync" &&
+        value.actor.external_subject.subject_ref === value.source.external_subject.subject_ref &&
+        sameInstallation(value.actor.external_subject.installation, value.source.installation) &&
+        value.actor.binding_ref === value.binding_ref &&
+        value.actor.membership.relay_project_ref === value.relay_project_ref);
+}
+export function isIntegrationManagedReferenceDeliveryResponse(value) {
+    return Value.Check(IntegrationManagedReferenceDeliveryResponseSchema, value);
+}
+export function isIntegrationConversationBindingRequest(value) {
+    if (!Value.Check(IntegrationConversationBindingRequestSchema, value)) {
+        return false;
+    }
+    return (value.installation.platform === "feishu" &&
+        value.external_subject.subject_kind === "human" &&
+        sameInstallation(value.installation, value.external_subject.installation));
+}
+export function isIntegrationConversationBindingResponse(value) {
+    return Value.Check(IntegrationConversationBindingResponseSchema, value);
+}
+export function isTrustedConversationSourceIngestionCommand(value) {
+    if (!Value.Check(TrustedConversationSourceIngestionCommandSchema, value)) {
+        return false;
+    }
+    const command = value;
+    const sourceInstallation = command.source.locator.conversation.installation;
+    const sourceAuthor = command.source.author;
+    return (command.receipt.event_kind === "conversation_source" &&
+        command.actor.external_subject.subject_kind ===
+            (command.actor.kind === "bot" ? "bot" : "human") &&
+        (command.actor.kind !== "bot" || command.actor.membership.label === "member") &&
+        command.actor.membership.relay_project_ref === command.relay_project_ref &&
+        command.actor.binding_ref === command.binding_ref &&
+        command.actor.account_ref === sourceAuthor.account_ref &&
+        command.actor.display_name === sourceAuthor.display_name &&
+        sameExternalSubject(command.actor.external_subject, sourceAuthor.external_subject) &&
+        sameInstallation(command.receipt.installation, sourceInstallation) &&
+        sameInstallation(command.receipt.installation, sourceAuthor.external_subject.installation));
+}
+export function isTrustedReferenceAttachmentIngestionCommand(value) {
+    if (!Value.Check(TrustedReferenceAttachmentIngestionCommandSchema, value)) {
+        return false;
+    }
+    return (validPreIdentityReferenceAttachmentAuthority(value) &&
+        value.actor.channel === "platform_chat" &&
+        value.actor.membership.relay_project_ref === value.relay_project_ref &&
+        value.actor.binding_ref === value.binding_ref &&
+        sameExternalSubject(value.actor.external_subject, value.source.author.external_subject) &&
+        value.source.attachment.file_name === value.staged_upload.file_name &&
+        value.source.attachment.media_type === value.staged_upload.media_type);
+}
+export function isIntegrationDeliveryTunnelMetadata(value) {
+    return Value.Check(IntegrationDeliveryTunnelMetadataSchema, value);
+}
+export function isIntegrationConversationSourceDeliveryResponse(value) {
+    return Value.Check(IntegrationConversationSourceDeliveryResponseSchema, value);
+}
+export function isIntegrationApprovalDecisionDeliveryRequest(value) {
+    if (!Value.Check(IntegrationApprovalDecisionDeliveryRequestSchema, value)) {
+        return false;
+    }
+    return (value.receipt.event_kind === "card_action" &&
+        value.callback.external_subject.subject_kind === "human" &&
+        sameInstallation(value.receipt.installation, value.callback.external_subject.installation));
+}
+export function isTrustedApprovalDecisionCommand(value) {
+    if (!Value.Check(TrustedApprovalDecisionCommandSchema, value)) {
+        return false;
+    }
+    return (value.receipt.event_kind === "card_action" &&
+        value.actor.channel === "platform_card_callback" &&
+        value.actor.membership.relay_project_ref === value.relay_project_ref &&
+        value.actor.binding_ref === value.binding_ref &&
+        sameInstallation(value.receipt.installation, value.actor.external_subject.installation));
+}
+export function isIntegrationApprovalDecisionDeliveryResponse(value) {
+    return Value.Check(IntegrationApprovalDecisionDeliveryResponseSchema, value);
+}
+export function isPlatformOutboundTextIntent(value) {
+    return Value.Check(PlatformOutboundIntentSchema, value);
+}
+export function isPlatformOutboundIntent(value) {
+    return Value.Check(PlatformOutboundIntentSchema, value);
+}
+export function isRelayAuthorizedPlatformOutboundTextIntent(value) {
+    return Value.Check(RelayAuthorizedPlatformOutboundIntentSchema, value);
+}
+export function isRelayAuthorizedPlatformOutboundIntent(value) {
+    return Value.Check(RelayAuthorizedPlatformOutboundIntentSchema, value);
+}
+export function isIntegrationOutboundClaimRequest(value) {
+    return (Value.Check(IntegrationOutboundClaimRequestSchema, value) &&
+        value.installation.platform === "feishu");
+}
+export function isIntegrationOutboundClaimResponse(value) {
+    return Value.Check(IntegrationOutboundClaimResponseSchema, value);
+}
+export function isIntegrationOutboundAckRequest(value) {
+    return (Value.Check(IntegrationOutboundAckRequestSchema, value) &&
+        value.installation.platform === "feishu");
+}
+export function isIntegrationOutboundAckResponse(value) {
+    return Value.Check(IntegrationOutboundAckResponseSchema, value);
+}
+export function isPlatformOutboundHandoffResponse(value) {
+    return Value.Check(PlatformOutboundHandoffResponseSchema, value);
+}
+//# sourceMappingURL=platform-integration.js.map