@contractspec/lib.contracts 1.62.0 → 1.64.0

package/dist/integrations/integrations.capability.js

@@ -1,726 +0,0 @@
-// @bun
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
-// src/capabilities/capabilities.ts
-import { compareVersions } from "compare-versions";
-var capKey = (key, version) => `${key}.v${version}`;
-
-class CapabilityRegistry {
-  items = new Map;
-  surfaceIndex = null;
-  register(spec) {
-    const key = capKey(spec.meta.key, spec.meta.version);
-    if (this.items.has(key))
-      throw new Error(`Duplicate capability ${key}`);
-    this.items.set(key, spec);
-    this.surfaceIndex = null;
-    return this;
-  }
-  list() {
-    return [...this.items.values()];
-  }
-  get(key, version) {
-    if (version != null)
-      return this.items.get(capKey(key, version));
-    let candidate;
-    for (const spec of this.items.values()) {
-      if (spec.meta.key !== key)
-        continue;
-      if (!candidate || compareVersions(spec.meta.version, candidate.meta.version) > 0) {
-        candidate = spec;
-      }
-    }
-    return candidate;
-  }
-  satisfies(requirement, additional) {
-    if (requirement.optional)
-      return true;
-    if (additional?.some((ref) => matchesRequirement(ref, requirement)))
-      return true;
-    const spec = requirement.version ? this.get(requirement.key, requirement.version) : this.get(requirement.key);
-    if (!spec)
-      return false;
-    if (requirement.kind && spec.meta.kind !== requirement.kind)
-      return false;
-    if (requirement.version != null && spec.meta.version !== requirement.version)
-      return false;
-    return true;
-  }
-  buildSurfaceIndex() {
-    if (this.surfaceIndex)
-      return this.surfaceIndex;
-    this.surfaceIndex = new Map;
-    for (const spec of this.items.values()) {
-      const capabilityKey = capKey(spec.meta.key, spec.meta.version);
-      for (const surface of spec.provides ?? []) {
-        const surfaceKey = `${surface.surface}:${surface.key}`;
-        if (!this.surfaceIndex.has(surfaceKey)) {
-          this.surfaceIndex.set(surfaceKey, new Set);
-        }
-        this.surfaceIndex.get(surfaceKey)?.add(capabilityKey);
-      }
-    }
-    return this.surfaceIndex;
-  }
-  getOperationsFor(capabilityKey, version) {
-    const spec = this.get(capabilityKey, version);
-    if (!spec)
-      return [];
-    return spec.provides?.filter((s) => s.surface === "operation").map((s) => s.key) ?? [];
-  }
-  getEventsFor(capabilityKey, version) {
-    const spec = this.get(capabilityKey, version);
-    if (!spec)
-      return [];
-    return spec.provides?.filter((s) => s.surface === "event").map((s) => s.key) ?? [];
-  }
-  getPresentationsFor(capabilityKey, version) {
-    const spec = this.get(capabilityKey, version);
-    if (!spec)
-      return [];
-    return spec.provides?.filter((s) => s.surface === "presentation").map((s) => s.key) ?? [];
-  }
-  getWorkflowsFor(capabilityKey, version) {
-    const spec = this.get(capabilityKey, version);
-    if (!spec)
-      return [];
-    return spec.provides?.filter((s) => s.surface === "workflow").map((s) => s.key) ?? [];
-  }
-  getResourcesFor(capabilityKey, version) {
-    const spec = this.get(capabilityKey, version);
-    if (!spec)
-      return [];
-    return spec.provides?.filter((s) => s.surface === "resource").map((s) => s.key) ?? [];
-  }
-  getCapabilitiesForOperation(operationKey) {
-    const index = this.buildSurfaceIndex();
-    const capKeys = index.get(`operation:${operationKey}`);
-    if (!capKeys)
-      return [];
-    return [...capKeys].map((k) => {
-      const spec = this.items.get(k);
-      return { key: spec?.meta.key ?? "", version: spec?.meta.version ?? "" };
-    });
-  }
-  getCapabilitiesForEvent(eventKey) {
-    const index = this.buildSurfaceIndex();
-    const capKeys = index.get(`event:${eventKey}`);
-    if (!capKeys)
-      return [];
-    return [...capKeys].map((k) => {
-      const spec = this.items.get(k);
-      return { key: spec?.meta.key ?? "", version: spec?.meta.version ?? "" };
-    });
-  }
-  getCapabilitiesForPresentation(presentationKey) {
-    const index = this.buildSurfaceIndex();
-    const capKeys = index.get(`presentation:${presentationKey}`);
-    if (!capKeys)
-      return [];
-    return [...capKeys].map((k) => {
-      const spec = this.items.get(k);
-      return { key: spec?.meta.key ?? "", version: spec?.meta.version ?? "" };
-    });
-  }
-  getAncestors(capabilityKey, version) {
-    const ancestors = [];
-    const visited = new Set;
-    let current = this.get(capabilityKey, version);
-    while (current?.extends) {
-      const parentKey = capKey(current.extends.key, current.extends.version);
-      if (visited.has(parentKey)) {
-        break;
-      }
-      visited.add(parentKey);
-      const parent = this.get(current.extends.key, current.extends.version);
-      if (!parent)
-        break;
-      ancestors.push(parent);
-      current = parent;
-    }
-    return ancestors;
-  }
-  getEffectiveRequirements(capabilityKey, version) {
-    const spec = this.get(capabilityKey, version);
-    if (!spec)
-      return [];
-    const ancestors = this.getAncestors(capabilityKey, version);
-    const requirementMap = new Map;
-    for (const ancestor of [...ancestors].reverse()) {
-      for (const req of ancestor.requires ?? []) {
-        requirementMap.set(req.key, req);
-      }
-    }
-    for (const req of spec.requires ?? []) {
-      requirementMap.set(req.key, req);
-    }
-    return [...requirementMap.values()];
-  }
-  getEffectiveSurfaces(capabilityKey, version) {
-    const spec = this.get(capabilityKey, version);
-    if (!spec)
-      return [];
-    const ancestors = this.getAncestors(capabilityKey, version);
-    const surfaces = [];
-    for (const ancestor of [...ancestors].reverse()) {
-      surfaces.push(...ancestor.provides ?? []);
-    }
-    surfaces.push(...spec.provides ?? []);
-    return surfaces;
-  }
-}
-function matchesRequirement(ref, requirement) {
-  if (ref.key !== requirement.key)
-    return false;
-  if (requirement.version != null && ref.version !== requirement.version)
-    return false;
-  return true;
-}
-function capabilityKey(spec) {
-  return capKey(spec.meta.key, spec.meta.version);
-}
-function defineCapability(spec) {
-  return spec;
-}
-
-// src/capabilities/validation.ts
-function validateCapabilityConsistency(deps) {
-  const errors = [];
-  const warnings = [];
-  for (const capability of deps.capabilities.list()) {
-    const capKey2 = `${capability.meta.key}.v${capability.meta.version}`;
-    for (const surface of capability.provides ?? []) {
-      const exists = checkSurfaceExists(deps, surface.surface, surface.key);
-      if (!exists) {
-        errors.push({
-          type: "missing_surface_spec",
-          message: `Capability "${capKey2}" provides ${surface.surface} "${surface.key}" but spec not found`,
-          capabilityKey: capKey2,
-          surface: surface.surface,
-          specKey: surface.key
-        });
-      }
-    }
-  }
-  if (deps.operations) {
-    for (const op of deps.operations.list()) {
-      if (op.capability) {
-        const capSpec = deps.capabilities.get(op.capability.key, op.capability.version);
-        if (!capSpec) {
-          errors.push({
-            type: "capability_not_found",
-            message: `Operation "${op.meta.key}" references capability "${op.capability.key}.v${op.capability.version}" but capability not found`,
-            specKey: op.meta.key,
-            capabilityKey: `${op.capability.key}.v${op.capability.version}`,
-            surface: "operation"
-          });
-        } else {
-          const inProvides = capSpec.provides?.some((p) => p.surface === "operation" && p.key === op.meta.key);
-          if (!inProvides) {
-            errors.push({
-              type: "surface_not_in_provides",
-              message: `Operation "${op.meta.key}" claims capability "${op.capability.key}.v${op.capability.version}" but not in capability's provides`,
-              specKey: op.meta.key,
-              capabilityKey: `${op.capability.key}.v${op.capability.version}`,
-              surface: "operation"
-            });
-          }
-        }
-      }
-    }
-  }
-  if (deps.events) {
-    for (const event of deps.events.list()) {
-      if (event.capability) {
-        const capSpec = deps.capabilities.get(event.capability.key, event.capability.version);
-        if (!capSpec) {
-          errors.push({
-            type: "capability_not_found",
-            message: `Event "${event.meta.key}" references capability "${event.capability.key}.v${event.capability.version}" but capability not found`,
-            specKey: event.meta.key,
-            capabilityKey: `${event.capability.key}.v${event.capability.version}`,
-            surface: "event"
-          });
-        } else {
-          const inProvides = capSpec.provides?.some((p) => p.surface === "event" && p.key === event.meta.key);
-          if (!inProvides) {
-            errors.push({
-              type: "surface_not_in_provides",
-              message: `Event "${event.meta.key}" claims capability "${event.capability.key}.v${event.capability.version}" but not in capability's provides`,
-              specKey: event.meta.key,
-              capabilityKey: `${event.capability.key}.v${event.capability.version}`,
-              surface: "event"
-            });
-          }
-        }
-      }
-    }
-  }
-  if (deps.presentations) {
-    for (const pres of deps.presentations.list()) {
-      if (pres.capability) {
-        const capSpec = deps.capabilities.get(pres.capability.key, pres.capability.version);
-        if (!capSpec) {
-          errors.push({
-            type: "capability_not_found",
-            message: `Presentation "${pres.meta.key}" references capability "${pres.capability.key}.v${pres.capability.version}" but capability not found`,
-            specKey: pres.meta.key,
-            capabilityKey: `${pres.capability.key}.v${pres.capability.version}`,
-            surface: "presentation"
-          });
-        } else {
-          const inProvides = capSpec.provides?.some((p) => p.surface === "presentation" && p.key === pres.meta.key);
-          if (!inProvides) {
-            errors.push({
-              type: "surface_not_in_provides",
-              message: `Presentation "${pres.meta.key}" claims capability "${pres.capability.key}.v${pres.capability.version}" but not in capability's provides`,
-              specKey: pres.meta.key,
-              capabilityKey: `${pres.capability.key}.v${pres.capability.version}`,
-              surface: "presentation"
-            });
-          }
-        }
-      }
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings
-  };
-}
-function checkSurfaceExists(deps, surface, key) {
-  switch (surface) {
-    case "operation":
-      return deps.operations?.has(key) ?? true;
-    case "event":
-      return deps.events?.has(key) ?? true;
-    case "presentation":
-      return deps.presentations?.has(key) ?? true;
-    case "workflow":
-    case "resource":
-      return true;
-    default:
-      return true;
-  }
-}
-function findOrphanSpecs(deps) {
-  const result = {
-    operations: [],
-    events: [],
-    presentations: []
-  };
-  if (deps.operations) {
-    for (const op of deps.operations.list()) {
-      if (!op.capability) {
-        result.operations.push(op.meta.key);
-      }
-    }
-  }
-  if (deps.events) {
-    for (const event of deps.events.list()) {
-      if (!event.capability) {
-        result.events.push(event.meta.key);
-      }
-    }
-  }
-  if (deps.presentations) {
-    for (const pres of deps.presentations.list()) {
-      if (!pres.capability) {
-        result.presentations.push(pres.meta.key);
-      }
-    }
-  }
-  return result;
-}
-
-// src/capabilities/context.ts
-class CapabilityMissingError extends Error {
-  capabilityKey;
-  requiredVersion;
-  constructor(capabilityKey2, requiredVersion) {
-    const versionSuffix = requiredVersion ? `.v${requiredVersion}` : "";
-    super(`Missing required capability: ${capabilityKey2}${versionSuffix}`);
-    this.name = "CapabilityMissingError";
-    this.capabilityKey = capabilityKey2;
-    this.requiredVersion = requiredVersion;
-  }
-}
-
-class CapabilityContextImpl {
-  capabilities;
-  capabilityVersions;
-  constructor(enabledCapabilities) {
-    const capSet = new Set;
-    const versionMap = new Map;
-    for (const cap of enabledCapabilities) {
-      capSet.add(cap.key);
-      versionMap.set(cap.key, cap.version);
-    }
-    this.capabilities = capSet;
-    this.capabilityVersions = versionMap;
-  }
-  hasCapability(key, version) {
-    if (!this.capabilities.has(key))
-      return false;
-    if (version != null) {
-      const enabledVersion = this.capabilityVersions.get(key);
-      return enabledVersion === version;
-    }
-    return true;
-  }
-  requireCapability(key, version) {
-    if (!this.hasCapability(key, version)) {
-      throw new CapabilityMissingError(key, version);
-    }
-  }
-  hasAllCapabilities(keys) {
-    return keys.every((k) => this.capabilities.has(k));
-  }
-  hasAnyCapability(keys) {
-    return keys.some((k) => this.capabilities.has(k));
-  }
-  getMatchingCapabilities(pattern) {
-    if (!pattern.includes("*")) {
-      return this.capabilities.has(pattern) ? [pattern] : [];
-    }
-    const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-    const regex = new RegExp(`^${regexPattern}$`);
-    return [...this.capabilities].filter((key) => regex.test(key));
-  }
-}
-function createCapabilityContext(enabledCapabilities) {
-  return new CapabilityContextImpl(enabledCapabilities);
-}
-function createEmptyCapabilityContext() {
-  return new CapabilityContextImpl([]);
-}
-function createBypassCapabilityContext(allCapabilities) {
-  return new CapabilityContextImpl(allCapabilities);
-}
-
-// src/capabilities/guards.ts
-function checkCapabilityForOperation(ctx, operation) {
-  if (!operation.capability) {
-    return { allowed: true };
-  }
-  const { key, version } = operation.capability;
-  if (ctx.hasCapability(key, version)) {
-    return { allowed: true };
-  }
-  return {
-    allowed: false,
-    missingCapability: { key, version },
-    reason: `Operation "${operation.meta.key}" requires capability "${key}.v${version}"`
-  };
-}
-function assertCapabilityForOperation(ctx, operation) {
-  const result = checkCapabilityForOperation(ctx, operation);
-  if (!result.allowed && result.missingCapability) {
-    throw new CapabilityMissingError(result.missingCapability.key, result.missingCapability.version);
-  }
-}
-function checkCapabilityForEvent(ctx, event) {
-  if (!event.capability) {
-    return { allowed: true };
-  }
-  const { key, version } = event.capability;
-  if (ctx.hasCapability(key, version)) {
-    return { allowed: true };
-  }
-  return {
-    allowed: false,
-    missingCapability: { key, version },
-    reason: `Event "${event.meta.key}" requires capability "${key}.v${version}"`
-  };
-}
-function assertCapabilityForEvent(ctx, event) {
-  const result = checkCapabilityForEvent(ctx, event);
-  if (!result.allowed && result.missingCapability) {
-    throw new CapabilityMissingError(result.missingCapability.key, result.missingCapability.version);
-  }
-}
-function checkCapabilityForPresentation(ctx, presentation) {
-  if (!presentation.capability) {
-    return { allowed: true };
-  }
-  const { key, version } = presentation.capability;
-  if (ctx.hasCapability(key, version)) {
-    return { allowed: true };
-  }
-  return {
-    allowed: false,
-    missingCapability: { key, version },
-    reason: `Presentation "${presentation.meta.key}" requires capability "${key}.v${version}"`
-  };
-}
-function assertCapabilityForPresentation(ctx, presentation) {
-  const result = checkCapabilityForPresentation(ctx, presentation);
-  if (!result.allowed && result.missingCapability) {
-    throw new CapabilityMissingError(result.missingCapability.key, result.missingCapability.version);
-  }
-}
-function filterOperationsByCapability(ctx, operations) {
-  return operations.filter((op) => checkCapabilityForOperation(ctx, op).allowed);
-}
-function filterEventsByCapability(ctx, events) {
-  return events.filter((ev) => checkCapabilityForEvent(ctx, ev).allowed);
-}
-function filterPresentationsByCapability(ctx, presentations) {
-  return presentations.filter((pres) => checkCapabilityForPresentation(ctx, pres).allowed);
-}
-
-// src/ownership.ts
-var StabilityEnum = {
-  Idea: "idea",
-  InCreation: "in_creation",
-  Experimental: "experimental",
-  Beta: "beta",
-  Stable: "stable",
-  Deprecated: "deprecated"
-};
-var OwnersEnum = {
-  PlatformCore: "platform.core",
-  PlatformSigil: "platform.sigil",
-  PlatformMarketplace: "platform.marketplace",
-  PlatformMessaging: "platform.messaging",
-  PlatformContent: "platform.content",
-  PlatformFeatureFlags: "platform.featureflags",
-  PlatformFinance: "platform.finance"
-};
-var Owners = OwnersEnum;
-var TagsEnum = {
-  Spots: "spots",
-  Collectivity: "collectivity",
-  Marketplace: "marketplace",
-  Sellers: "sellers",
-  Auth: "auth",
-  Login: "login",
-  Signup: "signup",
-  Guide: "guide",
-  Docs: "docs",
-  I18n: "i18n",
-  Incident: "incident",
-  Automation: "automation",
-  Hygiene: "hygiene"
-};
-var Tags = TagsEnum;
-
-// src/capabilities/openbanking.ts
-var OWNERS = ["platform.finance"];
-var TAGS = ["open-banking", "finance"];
-var openBankingAccountsReadCapability = {
-  meta: {
-    key: "openbanking.accounts.read",
-    version: "1.0.0",
-    kind: "integration",
-    title: "Open Banking Accounts (Read)",
-    description: "Provides read-only access to linked bank accounts, including account summaries and metadata.",
-    domain: "finance",
-    owners: [...OWNERS],
-    tags: [...TAGS],
-    stability: StabilityEnum.Experimental
-  },
-  provides: [
-    {
-      surface: "operation",
-      key: "openbanking.accounts.list",
-      version: "1.0.0",
-      description: "List bank accounts linked to a Powens open banking connection."
-    },
-    {
-      surface: "operation",
-      key: "openbanking.accounts.get",
-      version: "1.0.0",
-      description: "Retrieve the canonical bank account record for a specific account."
-    },
-    {
-      surface: "operation",
-      key: "openbanking.accounts.sync",
-      version: "1.0.0",
-      description: "Trigger a refresh of bank account metadata from the open banking provider."
-    }
-  ]
-};
-var openBankingTransactionsReadCapability = {
-  meta: {
-    key: "openbanking.transactions.read",
-    version: "1.0.0",
-    kind: "integration",
-    title: "Open Banking Transactions (Read)",
-    description: "Enables retrieval of transaction history for linked bank accounts via open banking providers.",
-    domain: "finance",
-    owners: [...OWNERS],
-    tags: [...TAGS, "transactions"],
-    stability: StabilityEnum.Experimental
-  },
-  provides: [
-    {
-      surface: "operation",
-      key: "openbanking.transactions.list",
-      version: "1.0.0",
-      description: "List transactions for a given bank account with optional date filtering."
-    },
-    {
-      surface: "operation",
-      key: "openbanking.transactions.sync",
-      version: "1.0.0",
-      description: "Synchronise transactions from the open banking provider into the canonical ledger."
-    }
-  ]
-};
-var openBankingBalancesReadCapability = {
-  meta: {
-    key: "openbanking.balances.read",
-    version: "1.0.0",
-    kind: "integration",
-    title: "Open Banking Balances (Read)",
-    description: "Allows querying of current and available balances for linked bank accounts via open banking providers.",
-    domain: "finance",
-    owners: [...OWNERS],
-    tags: [...TAGS, "balances"],
-    stability: StabilityEnum.Experimental
-  },
-  provides: [
-    {
-      surface: "operation",
-      key: "openbanking.balances.get",
-      version: "1.0.0",
-      description: "Retrieve the latest known balances for a specified bank account."
-    },
-    {
-      surface: "operation",
-      key: "openbanking.balances.refresh",
-      version: "1.0.0",
-      description: "Force a balance refresh from the open banking provider."
-    }
-  ]
-};
-function registerOpenBankingCapabilities(registry) {
-  return registry.register(openBankingAccountsReadCapability).register(openBankingTransactionsReadCapability).register(openBankingBalancesReadCapability);
-}
-
-// src/capabilities/meeting-recorder.ts
-var OWNERS2 = ["platform.integrations"];
-var TAGS2 = ["meeting-recorder", "transcripts", "integrations"];
-var meetingRecorderMeetingsReadCapability = {
-  meta: {
-    key: "meeting-recorder.meetings.read",
-    version: "1.0.0",
-    kind: "integration",
-    title: "Meeting Recorder Meetings (Read)",
-    description: "Provides read-only access to recorded meetings and their metadata.",
-    domain: "integrations",
-    owners: [...OWNERS2],
-    tags: [...TAGS2, "meetings"],
-    stability: StabilityEnum.Experimental
-  },
-  provides: [
-    {
-      surface: "operation",
-      key: "meeting-recorder.meetings.list",
-      version: "1.0.0",
-      description: "List meetings available from the recorder provider."
-    },
-    {
-      surface: "operation",
-      key: "meeting-recorder.meetings.get",
-      version: "1.0.0",
-      description: "Fetch detailed metadata for a specific meeting."
-    }
-  ]
-};
-var meetingRecorderTranscriptsReadCapability = {
-  meta: {
-    key: "meeting-recorder.transcripts.read",
-    version: "1.0.0",
-    kind: "integration",
-    title: "Meeting Recorder Transcripts (Read)",
-    description: "Enables retrieval of transcripts for recorded meetings from external providers.",
-    domain: "integrations",
-    owners: [...OWNERS2],
-    tags: [...TAGS2, "transcripts"],
-    stability: StabilityEnum.Experimental
-  },
-  provides: [
-    {
-      surface: "operation",
-      key: "meeting-recorder.transcripts.get",
-      version: "1.0.0",
-      description: "Fetch the transcript for a specific meeting recording."
-    },
-    {
-      surface: "operation",
-      key: "meeting-recorder.transcripts.sync",
-      version: "1.0.0",
-      description: "Trigger a transcript sync from the recorder provider."
-    }
-  ]
-};
-var meetingRecorderWebhooksCapability = {
-  meta: {
-    key: "meeting-recorder.webhooks",
-    version: "1.0.0",
-    kind: "integration",
-    title: "Meeting Recorder Webhooks",
-    description: "Allows processing of webhook events for meeting transcript readiness.",
-    domain: "integrations",
-    owners: [...OWNERS2],
-    tags: [...TAGS2, "webhooks"],
-    stability: StabilityEnum.Experimental
-  },
-  provides: [
-    {
-      surface: "operation",
-      key: "meeting-recorder.webhooks.ingest",
-      version: "1.0.0",
-      description: "Ingest and verify meeting recorder webhook payloads."
-    }
-  ]
-};
-function registerMeetingRecorderCapabilities(registry) {
-  return registry.register(meetingRecorderMeetingsReadCapability).register(meetingRecorderTranscriptsReadCapability).register(meetingRecorderWebhooksCapability);
-}
-// src/integrations/integrations.capability.ts
-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
-};