@forge/util

Index: package/packages/ari/platform/index.js
===================================================================
--- package/packages/ari/platform/index.js
+++ package/packages/ari/platform/index.js
@@ -16,20 +16,65 @@
 
 // src/platform/index.ts
 var platform_exports = {};
 __export(platform_exports, {
+  PlatformAccessAri: () => PlatformAccessAri,
+  PlatformActionAri: () => PlatformActionAri,
+  PlatformAppAri: () => PlatformAppAri,
+  PlatformAssetsAri: () => PlatformAssetsAri,
+  PlatformAtlassianAnalyticsAri: () => PlatformAtlassianAnalyticsAri,
+  PlatformBeaconAri: () => PlatformBeaconAri,
+  PlatformCanvasAri: () => PlatformCanvasAri,
   PlatformClassificationTagAri: () => PlatformClassificationTagAri,
   PlatformCollaborationContextAri: () => PlatformCollaborationContextAri,
+  PlatformCompassAri: () => PlatformCompassAri,
+  PlatformConfluenceAri: () => PlatformConfluenceAri,
+  PlatformCustomEmailFooterAri: () => PlatformCustomEmailFooterAri,
+  PlatformDevaiAri: () => PlatformDevaiAri,
+  PlatformEcosystemAppAri: () => PlatformEcosystemAppAri,
+  PlatformEnterpriseAppAri: () => PlatformEnterpriseAppAri,
+  PlatformEnterpriseConfluenceAri: () => PlatformEnterpriseConfluenceAri,
+  PlatformEnterpriseJiraServicedeskAri: () => PlatformEnterpriseJiraServicedeskAri,
+  PlatformEnterpriseJiraSoftwareAri: () => PlatformEnterpriseJiraSoftwareAri,
+  PlatformGoalAri: () => PlatformGoalAri,
+  PlatformGuardPremiumAri: () => PlatformGuardPremiumAri,
+  PlatformGuardPremiumInstanceAri: () => PlatformGuardPremiumInstanceAri,
   PlatformIntegrationAri: () => PlatformIntegrationAri,
+  PlatformJiraAlignAri: () => PlatformJiraAlignAri,
+  PlatformJiraCoreAri: () => PlatformJiraCoreAri,
+  PlatformJiraCustomerServiceAri: () => PlatformJiraCustomerServiceAri,
+  PlatformJiraProductDiscoveryAri: () => PlatformJiraProductDiscoveryAri,
+  PlatformJiraServicedeskAri: () => PlatformJiraServicedeskAri,
+  PlatformJiraSoftwareAri: () => PlatformJiraSoftwareAri,
+  PlatformJsmExtraAssetsAri: () => PlatformJsmExtraAssetsAri,
+  PlatformJsmExtraConversationsAri: () => PlatformJsmExtraConversationsAri,
   PlatformLifecycleResourceAri: () => PlatformLifecycleResourceAri,
   PlatformLifecycleResourcePackageAri: () => PlatformLifecycleResourcePackageAri,
   PlatformLifecycleResourcePackageTypeAri: () => PlatformLifecycleResourcePackageTypeAri,
+  PlatformLoomAri: () => PlatformLoomAri,
+  PlatformMcpToolAri: () => PlatformMcpToolAri,
+  PlatformMercuryAri: () => PlatformMercuryAri,
+  PlatformOpsgenieAri: () => PlatformOpsgenieAri,
   PlatformOrgAri: () => PlatformOrgAri,
   PlatformOrgUserAri: () => PlatformOrgUserAri,
+  PlatformOrganizationClassificationHistoryAri: () => PlatformOrganizationClassificationHistoryAri,
+  PlatformPassionfruitAri: () => PlatformPassionfruitAri,
   PlatformProductAri: () => PlatformProductAri,
+  PlatformProductCollaborationContextConnectionAri: () => PlatformProductCollaborationContextConnectionAri,
+  PlatformProjectAri: () => PlatformProjectAri,
+  PlatformRadarAri: () => PlatformRadarAri,
+  PlatformRovoAri: () => PlatformRovoAri,
+  PlatformRovoInstanceAri: () => PlatformRovoInstanceAri,
   PlatformSecureTunnelAri: () => PlatformSecureTunnelAri,
   PlatformSiteAri: () => PlatformSiteAri,
-  PlatformTestProvisioningEntityAri: () => PlatformTestProvisioningEntityAri
+  PlatformStatuspagePageAri: () => PlatformStatuspagePageAri,
+  PlatformStatuspageProductAri: () => PlatformStatuspageProductAri,
+  PlatformSyntheticAAri: () => PlatformSyntheticAAri,
+  PlatformSyntheticAri: () => PlatformSyntheticAri,
+  PlatformTestProvisioningEntityAri: () => PlatformTestProvisioningEntityAri,
+  PlatformTownsquareAri: () => PlatformTownsquareAri,
+  PlatformUnifiedHelpAri: () => PlatformUnifiedHelpAri,
+  PlatformUnitAri: () => PlatformUnitAri
 });
 module.exports = __toCommonJS(platform_exports);
 
 // src/errors.ts
@@ -285,31 +330,371 @@
     return AnyAri.parse(this.toString());
   }
 };
 
+// src/platform/access/types.ts
+var PlatformAccessAriResourceOwner = "platform", PlatformAccessAriResourceType = "access";
+
+// src/platform/access/manifest.ts
+var platformAccessAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformAccessAriResourceOwner,
+  resourceType: PlatformAccessAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/access/index.ts
+var PlatformAccessAri = class _PlatformAccessAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformAccessAriStaticOpts.qualifier,
+      platformQualifier: platformAccessAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformAccessAriStaticOpts.resourceOwner,
+      resourceType: platformAccessAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformAccessAriStaticOpts);
+    return new _PlatformAccessAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformAccessAriStaticOpts);
+    return new _PlatformAccessAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/action/types.ts
+var PlatformActionAriResourceOwner = "platform", PlatformActionAriResourceType = "action";
+
+// src/platform/action/manifest.ts
+var platformActionAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformActionAriResourceOwner,
+  resourceType: PlatformActionAriResourceType,
+  resourceIdSlug: "{actionId}",
+  resourceIdSegmentFormats: {
+    actionId: /[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}/
+  }
+};
+
+// src/platform/action/index.ts
+var PlatformActionAri = class _PlatformActionAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._actionId = opts.resourceIdSegmentValues.actionId;
+  }
+  get actionId() {
+    return this._actionId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformActionAriStaticOpts.qualifier,
+      platformQualifier: platformActionAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformActionAriStaticOpts.resourceOwner,
+      resourceType: platformActionAriStaticOpts.resourceType,
+      resourceId: `${opts.actionId}`,
+      resourceIdSegmentValues: {
+        actionId: opts.actionId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformActionAriStaticOpts);
+    return new _PlatformActionAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformActionAriStaticOpts);
+    return new _PlatformActionAri(opts);
+  }
+  getVariables() {
+    return {
+      actionId: this.actionId
+    };
+  }
+};
+
+// src/platform/app/types.ts
+var PlatformAppAriResourceOwner = "platform";
+
+// src/platform/app/manifest.ts
+var platformAppAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformAppAriResourceOwner,
+  resourceType: "app",
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/app/index.ts
+var PlatformAppAri = class _PlatformAppAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformAppAriStaticOpts.qualifier,
+      platformQualifier: platformAppAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformAppAriStaticOpts.resourceOwner,
+      resourceType: platformAppAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformAppAriStaticOpts);
+    return new _PlatformAppAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformAppAriStaticOpts);
+    return new _PlatformAppAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/assets/types.ts
+var PlatformAssetsAriResourceOwner = "platform", PlatformAssetsAriResourceType = "assets";
+
+// src/platform/assets/manifest.ts
+var platformAssetsAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformAssetsAriResourceOwner,
+  resourceType: PlatformAssetsAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/assets/index.ts
+var PlatformAssetsAri = class _PlatformAssetsAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformAssetsAriStaticOpts.qualifier,
+      platformQualifier: platformAssetsAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformAssetsAriStaticOpts.resourceOwner,
+      resourceType: platformAssetsAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformAssetsAriStaticOpts);
+    return new _PlatformAssetsAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformAssetsAriStaticOpts);
+    return new _PlatformAssetsAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/atlassian-analytics/types.ts
+var PlatformAtlassianAnalyticsAriResourceOwner = "platform", PlatformAtlassianAnalyticsAriResourceType = "atlassian-analytics";
+
+// src/platform/atlassian-analytics/manifest.ts
+var platformAtlassianAnalyticsAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformAtlassianAnalyticsAriResourceOwner,
+  resourceType: PlatformAtlassianAnalyticsAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/atlassian-analytics/index.ts
+var PlatformAtlassianAnalyticsAri = class _PlatformAtlassianAnalyticsAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformAtlassianAnalyticsAriStaticOpts.qualifier,
+      platformQualifier: platformAtlassianAnalyticsAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformAtlassianAnalyticsAriStaticOpts.resourceOwner,
+      resourceType: platformAtlassianAnalyticsAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformAtlassianAnalyticsAriStaticOpts);
+    return new _PlatformAtlassianAnalyticsAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformAtlassianAnalyticsAriStaticOpts);
+    return new _PlatformAtlassianAnalyticsAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/beacon/types.ts
+var PlatformBeaconAriResourceOwner = "platform", PlatformBeaconAriResourceType = "beacon";
+
+// src/platform/beacon/manifest.ts
+var platformBeaconAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformBeaconAriResourceOwner,
+  resourceType: PlatformBeaconAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/beacon/index.ts
+var PlatformBeaconAri = class _PlatformBeaconAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformBeaconAriStaticOpts.qualifier,
+      platformQualifier: platformBeaconAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformBeaconAriStaticOpts.resourceOwner,
+      resourceType: platformBeaconAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformBeaconAriStaticOpts);
+    return new _PlatformBeaconAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformBeaconAriStaticOpts);
+    return new _PlatformBeaconAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/canvas/types.ts
+var PlatformCanvasAriResourceOwner = "platform", PlatformCanvasAriResourceType = "canvas";
+
+// src/platform/canvas/manifest.ts
+var platformCanvasAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformCanvasAriResourceOwner,
+  resourceType: PlatformCanvasAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/canvas/index.ts
+var PlatformCanvasAri = class _PlatformCanvasAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformCanvasAriStaticOpts.qualifier,
+      platformQualifier: platformCanvasAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformCanvasAriStaticOpts.resourceOwner,
+      resourceType: platformCanvasAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformCanvasAriStaticOpts);
+    return new _PlatformCanvasAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformCanvasAriStaticOpts);
+    return new _PlatformCanvasAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
 // src/platform/classification-tag/types.ts
 var PlatformClassificationTagAriResourceOwner = "platform", PlatformClassificationTagAriResourceType = "classification-tag";
 
 // src/platform/classification-tag/manifest.ts
 var platformClassificationTagAriStaticOpts = {
   qualifier: "ari",
   platformQualifier: "cloud",
   cloudId: new RegExp("^$"),
-  // eslint-disable-line no-useless-escape
   resourceOwner: PlatformClassificationTagAriResourceOwner,
   resourceType: PlatformClassificationTagAriResourceType,
   resourceIdSlug: "{tagId}",
   resourceIdSegmentFormats: {
     tagId: /[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}/
-    // eslint-disable-line no-useless-escape
   }
 };
 
 // src/platform/classification-tag/index.ts
 var PlatformClassificationTagAri = class _PlatformClassificationTagAri extends RegisteredAri {
   constructor(opts) {
-    super(opts);
-    this._tagId = opts.resourceIdSegmentValues.tagId;
+    super(opts), this._tagId = opts.resourceIdSegmentValues.tagId;
   }
   get tagId() {
     return this._tagId;
   }
@@ -345,9 +730,8 @@
 var platformCollaborationContextAriStaticOpts = {
   qualifier: "ari",
   platformQualifier: "cloud",
   cloudId: new RegExp("^$"),
-  // eslint-disable-line no-useless-escape
   resourceOwner: PlatformCollaborationContextAriResourceOwner,
   resourceType: PlatformCollaborationContextAriResourceType,
   resourceIdSlug: "{collaborationContextId}",
   resourceIdSegmentFormats: {
@@ -358,10 +742,9 @@
 
 // src/platform/collaboration-context/index.ts
 var PlatformCollaborationContextAri = class _PlatformCollaborationContextAri extends RegisteredAri {
   constructor(opts) {
-    super(opts);
-    this._collaborationContextId = opts.resourceIdSegmentValues.collaborationContextId;
+    super(opts), this._collaborationContextId = opts.resourceIdSegmentValues.collaborationContextId;
   }
   get collaborationContextId() {
     return this._collaborationContextId;
   }
@@ -389,31 +772,623 @@
     };
   }
 };
 
+// src/platform/compass/types.ts
+var PlatformCompassAriResourceOwner = "platform", PlatformCompassAriResourceType = "compass";
+
+// src/platform/compass/manifest.ts
+var platformCompassAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformCompassAriResourceOwner,
+  resourceType: PlatformCompassAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/compass/index.ts
+var PlatformCompassAri = class _PlatformCompassAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformCompassAriStaticOpts.qualifier,
+      platformQualifier: platformCompassAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformCompassAriStaticOpts.resourceOwner,
+      resourceType: platformCompassAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformCompassAriStaticOpts);
+    return new _PlatformCompassAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformCompassAriStaticOpts);
+    return new _PlatformCompassAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/confluence/types.ts
+var PlatformConfluenceAriResourceOwner = "platform", PlatformConfluenceAriResourceType = "confluence";
+
+// src/platform/confluence/manifest.ts
+var platformConfluenceAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformConfluenceAriResourceOwner,
+  resourceType: PlatformConfluenceAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/confluence/index.ts
+var PlatformConfluenceAri = class _PlatformConfluenceAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformConfluenceAriStaticOpts.qualifier,
+      platformQualifier: platformConfluenceAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformConfluenceAriStaticOpts.resourceOwner,
+      resourceType: platformConfluenceAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformConfluenceAriStaticOpts);
+    return new _PlatformConfluenceAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformConfluenceAriStaticOpts);
+    return new _PlatformConfluenceAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/custom-email-footer/types.ts
+var PlatformCustomEmailFooterAriResourceOwner = "platform", PlatformCustomEmailFooterAriResourceType = "custom-email-footer";
+
+// src/platform/custom-email-footer/manifest.ts
+var platformCustomEmailFooterAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformCustomEmailFooterAriResourceOwner,
+  resourceType: PlatformCustomEmailFooterAriResourceType,
+  resourceIdSlug: "{orgId}/{appName}",
+  resourceIdSegmentFormats: {
+    orgId: /[a-zA-Z0-9\-]+/,
+    // eslint-disable-line no-useless-escape
+    appName: /[a-z]+(?:-[a-z]+)*/
+  }
+};
+
+// src/platform/custom-email-footer/index.ts
+var PlatformCustomEmailFooterAri = class _PlatformCustomEmailFooterAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._orgId = opts.resourceIdSegmentValues.orgId, this._appName = opts.resourceIdSegmentValues.appName;
+  }
+  get orgId() {
+    return this._orgId;
+  }
+  get appName() {
+    return this._appName;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformCustomEmailFooterAriStaticOpts.qualifier,
+      platformQualifier: platformCustomEmailFooterAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformCustomEmailFooterAriStaticOpts.resourceOwner,
+      resourceType: platformCustomEmailFooterAriStaticOpts.resourceType,
+      resourceId: `${opts.orgId}/${opts.appName}`,
+      resourceIdSegmentValues: {
+        orgId: opts.orgId,
+        appName: opts.appName
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformCustomEmailFooterAriStaticOpts);
+    return new _PlatformCustomEmailFooterAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformCustomEmailFooterAriStaticOpts);
+    return new _PlatformCustomEmailFooterAri(opts);
+  }
+  getVariables() {
+    return {
+      orgId: this.orgId,
+      appName: this.appName
+    };
+  }
+};
+
+// src/platform/devai/types.ts
+var PlatformDevaiAriResourceOwner = "platform", PlatformDevaiAriResourceType = "devai";
+
+// src/platform/devai/manifest.ts
+var platformDevaiAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformDevaiAriResourceOwner,
+  resourceType: PlatformDevaiAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/devai/index.ts
+var PlatformDevaiAri = class _PlatformDevaiAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformDevaiAriStaticOpts.qualifier,
+      platformQualifier: platformDevaiAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformDevaiAriStaticOpts.resourceOwner,
+      resourceType: platformDevaiAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformDevaiAriStaticOpts);
+    return new _PlatformDevaiAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformDevaiAriStaticOpts);
+    return new _PlatformDevaiAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/ecosystem-app/types.ts
+var PlatformEcosystemAppAriResourceOwner = "platform", PlatformEcosystemAppAriResourceType = "ecosystem-app";
+
+// src/platform/ecosystem-app/manifest.ts
+var platformEcosystemAppAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformEcosystemAppAriResourceOwner,
+  resourceType: PlatformEcosystemAppAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/ecosystem-app/index.ts
+var PlatformEcosystemAppAri = class _PlatformEcosystemAppAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformEcosystemAppAriStaticOpts.qualifier,
+      platformQualifier: platformEcosystemAppAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformEcosystemAppAriStaticOpts.resourceOwner,
+      resourceType: platformEcosystemAppAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformEcosystemAppAriStaticOpts);
+    return new _PlatformEcosystemAppAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformEcosystemAppAriStaticOpts);
+    return new _PlatformEcosystemAppAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/enterprise-app/types.ts
+var PlatformEnterpriseAppAriResourceOwner = "platform", PlatformEnterpriseAppAriResourceType = "enterprise-app";
+
+// src/platform/enterprise-app/manifest.ts
+var platformEnterpriseAppAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformEnterpriseAppAriResourceOwner,
+  resourceType: PlatformEnterpriseAppAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/enterprise-app/index.ts
+var PlatformEnterpriseAppAri = class _PlatformEnterpriseAppAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformEnterpriseAppAriStaticOpts.qualifier,
+      platformQualifier: platformEnterpriseAppAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformEnterpriseAppAriStaticOpts.resourceOwner,
+      resourceType: platformEnterpriseAppAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformEnterpriseAppAriStaticOpts);
+    return new _PlatformEnterpriseAppAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformEnterpriseAppAriStaticOpts);
+    return new _PlatformEnterpriseAppAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/enterprise-confluence/types.ts
+var PlatformEnterpriseConfluenceAriResourceOwner = "platform", PlatformEnterpriseConfluenceAriResourceType = "enterprise-confluence";
+
+// src/platform/enterprise-confluence/manifest.ts
+var platformEnterpriseConfluenceAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformEnterpriseConfluenceAriResourceOwner,
+  resourceType: PlatformEnterpriseConfluenceAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/enterprise-confluence/index.ts
+var PlatformEnterpriseConfluenceAri = class _PlatformEnterpriseConfluenceAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformEnterpriseConfluenceAriStaticOpts.qualifier,
+      platformQualifier: platformEnterpriseConfluenceAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformEnterpriseConfluenceAriStaticOpts.resourceOwner,
+      resourceType: platformEnterpriseConfluenceAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformEnterpriseConfluenceAriStaticOpts);
+    return new _PlatformEnterpriseConfluenceAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformEnterpriseConfluenceAriStaticOpts);
+    return new _PlatformEnterpriseConfluenceAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/enterprise-jira-servicedesk/types.ts
+var PlatformEnterpriseJiraServicedeskAriResourceOwner = "platform", PlatformEnterpriseJiraServicedeskAriResourceType = "enterprise-jira-servicedesk";
+
+// src/platform/enterprise-jira-servicedesk/manifest.ts
+var platformEnterpriseJiraServicedeskAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformEnterpriseJiraServicedeskAriResourceOwner,
+  resourceType: PlatformEnterpriseJiraServicedeskAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/enterprise-jira-servicedesk/index.ts
+var PlatformEnterpriseJiraServicedeskAri = class _PlatformEnterpriseJiraServicedeskAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformEnterpriseJiraServicedeskAriStaticOpts.qualifier,
+      platformQualifier: platformEnterpriseJiraServicedeskAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformEnterpriseJiraServicedeskAriStaticOpts.resourceOwner,
+      resourceType: platformEnterpriseJiraServicedeskAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformEnterpriseJiraServicedeskAriStaticOpts);
+    return new _PlatformEnterpriseJiraServicedeskAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformEnterpriseJiraServicedeskAriStaticOpts);
+    return new _PlatformEnterpriseJiraServicedeskAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/enterprise-jira-software/types.ts
+var PlatformEnterpriseJiraSoftwareAriResourceOwner = "platform", PlatformEnterpriseJiraSoftwareAriResourceType = "enterprise-jira-software";
+
+// src/platform/enterprise-jira-software/manifest.ts
+var platformEnterpriseJiraSoftwareAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformEnterpriseJiraSoftwareAriResourceOwner,
+  resourceType: PlatformEnterpriseJiraSoftwareAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/enterprise-jira-software/index.ts
+var PlatformEnterpriseJiraSoftwareAri = class _PlatformEnterpriseJiraSoftwareAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformEnterpriseJiraSoftwareAriStaticOpts.qualifier,
+      platformQualifier: platformEnterpriseJiraSoftwareAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformEnterpriseJiraSoftwareAriStaticOpts.resourceOwner,
+      resourceType: platformEnterpriseJiraSoftwareAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformEnterpriseJiraSoftwareAriStaticOpts);
+    return new _PlatformEnterpriseJiraSoftwareAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformEnterpriseJiraSoftwareAriStaticOpts);
+    return new _PlatformEnterpriseJiraSoftwareAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/goal/types.ts
+var PlatformGoalAriResourceOwner = "platform", PlatformGoalAriResourceType = "goal";
+
+// src/platform/goal/manifest.ts
+var platformGoalAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformGoalAriResourceOwner,
+  resourceType: PlatformGoalAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/goal/index.ts
+var PlatformGoalAri = class _PlatformGoalAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformGoalAriStaticOpts.qualifier,
+      platformQualifier: platformGoalAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformGoalAriStaticOpts.resourceOwner,
+      resourceType: platformGoalAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformGoalAriStaticOpts);
+    return new _PlatformGoalAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformGoalAriStaticOpts);
+    return new _PlatformGoalAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/guard-premium/types.ts
+var PlatformGuardPremiumAriResourceOwner = "platform", PlatformGuardPremiumAriResourceType = "guard-premium";
+
+// src/platform/guard-premium/manifest.ts
+var platformGuardPremiumAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformGuardPremiumAriResourceOwner,
+  resourceType: PlatformGuardPremiumAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/guard-premium/index.ts
+var PlatformGuardPremiumAri = class _PlatformGuardPremiumAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformGuardPremiumAriStaticOpts.qualifier,
+      platformQualifier: platformGuardPremiumAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformGuardPremiumAriStaticOpts.resourceOwner,
+      resourceType: platformGuardPremiumAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformGuardPremiumAriStaticOpts);
+    return new _PlatformGuardPremiumAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformGuardPremiumAriStaticOpts);
+    return new _PlatformGuardPremiumAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/guard-premium-instance/types.ts
+var PlatformGuardPremiumInstanceAriResourceOwner = "platform", PlatformGuardPremiumInstanceAriResourceType = "guard-premium-instance";
+
+// src/platform/guard-premium-instance/manifest.ts
+var platformGuardPremiumInstanceAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformGuardPremiumInstanceAriResourceOwner,
+  resourceType: PlatformGuardPremiumInstanceAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/guard-premium-instance/index.ts
+var PlatformGuardPremiumInstanceAri = class _PlatformGuardPremiumInstanceAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformGuardPremiumInstanceAriStaticOpts.qualifier,
+      platformQualifier: platformGuardPremiumInstanceAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformGuardPremiumInstanceAriStaticOpts.resourceOwner,
+      resourceType: platformGuardPremiumInstanceAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformGuardPremiumInstanceAriStaticOpts);
+    return new _PlatformGuardPremiumInstanceAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformGuardPremiumInstanceAriStaticOpts);
+    return new _PlatformGuardPremiumInstanceAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
 // src/platform/integration/types.ts
 var PlatformIntegrationAriResourceOwner = "platform", PlatformIntegrationAriResourceType = "integration";
 
 // src/platform/integration/manifest.ts
 var platformIntegrationAriStaticOpts = {
   qualifier: "ari",
   platformQualifier: "cloud",
   cloudId: new RegExp("^$"),
-  // eslint-disable-line no-useless-escape
   resourceOwner: PlatformIntegrationAriResourceOwner,
   resourceType: PlatformIntegrationAriResourceType,
   resourceIdSlug: "{integrationKey}",
   resourceIdSegmentFormats: {
     integrationKey: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
-    // eslint-disable-line no-useless-escape
   }
 };
 
 // src/platform/integration/index.ts
 var PlatformIntegrationAri = class _PlatformIntegrationAri extends RegisteredAri {
   constructor(opts) {
-    super(opts);
-    this._integrationKey = opts.resourceIdSegmentValues.integrationKey;
+    super(opts), this._integrationKey = opts.resourceIdSegmentValues.integrationKey;
   }
   get integrationKey() {
     return this._integrationKey;
   }
@@ -441,31 +1416,420 @@
     };
   }
 };
 
+// src/platform/jira-align/types.ts
+var PlatformJiraAlignAriResourceOwner = "platform", PlatformJiraAlignAriResourceType = "jira-align";
+
+// src/platform/jira-align/manifest.ts
+var platformJiraAlignAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformJiraAlignAriResourceOwner,
+  resourceType: PlatformJiraAlignAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/jira-align/index.ts
+var PlatformJiraAlignAri = class _PlatformJiraAlignAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformJiraAlignAriStaticOpts.qualifier,
+      platformQualifier: platformJiraAlignAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformJiraAlignAriStaticOpts.resourceOwner,
+      resourceType: platformJiraAlignAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformJiraAlignAriStaticOpts);
+    return new _PlatformJiraAlignAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformJiraAlignAriStaticOpts);
+    return new _PlatformJiraAlignAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/jira-core/types.ts
+var PlatformJiraCoreAriResourceOwner = "platform", PlatformJiraCoreAriResourceType = "jira-core";
+
+// src/platform/jira-core/manifest.ts
+var platformJiraCoreAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformJiraCoreAriResourceOwner,
+  resourceType: PlatformJiraCoreAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/jira-core/index.ts
+var PlatformJiraCoreAri = class _PlatformJiraCoreAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformJiraCoreAriStaticOpts.qualifier,
+      platformQualifier: platformJiraCoreAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformJiraCoreAriStaticOpts.resourceOwner,
+      resourceType: platformJiraCoreAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformJiraCoreAriStaticOpts);
+    return new _PlatformJiraCoreAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformJiraCoreAriStaticOpts);
+    return new _PlatformJiraCoreAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/jira-customer-service/types.ts
+var PlatformJiraCustomerServiceAriResourceOwner = "platform", PlatformJiraCustomerServiceAriResourceType = "jira-customer-service";
+
+// src/platform/jira-customer-service/manifest.ts
+var platformJiraCustomerServiceAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformJiraCustomerServiceAriResourceOwner,
+  resourceType: PlatformJiraCustomerServiceAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/jira-customer-service/index.ts
+var PlatformJiraCustomerServiceAri = class _PlatformJiraCustomerServiceAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformJiraCustomerServiceAriStaticOpts.qualifier,
+      platformQualifier: platformJiraCustomerServiceAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformJiraCustomerServiceAriStaticOpts.resourceOwner,
+      resourceType: platformJiraCustomerServiceAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformJiraCustomerServiceAriStaticOpts);
+    return new _PlatformJiraCustomerServiceAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformJiraCustomerServiceAriStaticOpts);
+    return new _PlatformJiraCustomerServiceAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/jira-product-discovery/types.ts
+var PlatformJiraProductDiscoveryAriResourceOwner = "platform", PlatformJiraProductDiscoveryAriResourceType = "jira-product-discovery";
+
+// src/platform/jira-product-discovery/manifest.ts
+var platformJiraProductDiscoveryAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformJiraProductDiscoveryAriResourceOwner,
+  resourceType: PlatformJiraProductDiscoveryAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/jira-product-discovery/index.ts
+var PlatformJiraProductDiscoveryAri = class _PlatformJiraProductDiscoveryAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformJiraProductDiscoveryAriStaticOpts.qualifier,
+      platformQualifier: platformJiraProductDiscoveryAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformJiraProductDiscoveryAriStaticOpts.resourceOwner,
+      resourceType: platformJiraProductDiscoveryAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformJiraProductDiscoveryAriStaticOpts);
+    return new _PlatformJiraProductDiscoveryAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformJiraProductDiscoveryAriStaticOpts);
+    return new _PlatformJiraProductDiscoveryAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/jira-servicedesk/types.ts
+var PlatformJiraServicedeskAriResourceOwner = "platform", PlatformJiraServicedeskAriResourceType = "jira-servicedesk";
+
+// src/platform/jira-servicedesk/manifest.ts
+var platformJiraServicedeskAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformJiraServicedeskAriResourceOwner,
+  resourceType: PlatformJiraServicedeskAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/jira-servicedesk/index.ts
+var PlatformJiraServicedeskAri = class _PlatformJiraServicedeskAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformJiraServicedeskAriStaticOpts.qualifier,
+      platformQualifier: platformJiraServicedeskAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformJiraServicedeskAriStaticOpts.resourceOwner,
+      resourceType: platformJiraServicedeskAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformJiraServicedeskAriStaticOpts);
+    return new _PlatformJiraServicedeskAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformJiraServicedeskAriStaticOpts);
+    return new _PlatformJiraServicedeskAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/jira-software/types.ts
+var PlatformJiraSoftwareAriResourceOwner = "platform", PlatformJiraSoftwareAriResourceType = "jira-software";
+
+// src/platform/jira-software/manifest.ts
+var platformJiraSoftwareAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformJiraSoftwareAriResourceOwner,
+  resourceType: PlatformJiraSoftwareAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/jira-software/index.ts
+var PlatformJiraSoftwareAri = class _PlatformJiraSoftwareAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformJiraSoftwareAriStaticOpts.qualifier,
+      platformQualifier: platformJiraSoftwareAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformJiraSoftwareAriStaticOpts.resourceOwner,
+      resourceType: platformJiraSoftwareAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformJiraSoftwareAriStaticOpts);
+    return new _PlatformJiraSoftwareAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformJiraSoftwareAriStaticOpts);
+    return new _PlatformJiraSoftwareAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/jsm-extra-assets/types.ts
+var PlatformJsmExtraAssetsAriResourceOwner = "platform", PlatformJsmExtraAssetsAriResourceType = "jsm-extra-assets";
+
+// src/platform/jsm-extra-assets/manifest.ts
+var platformJsmExtraAssetsAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformJsmExtraAssetsAriResourceOwner,
+  resourceType: PlatformJsmExtraAssetsAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/jsm-extra-assets/index.ts
+var PlatformJsmExtraAssetsAri = class _PlatformJsmExtraAssetsAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformJsmExtraAssetsAriStaticOpts.qualifier,
+      platformQualifier: platformJsmExtraAssetsAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformJsmExtraAssetsAriStaticOpts.resourceOwner,
+      resourceType: platformJsmExtraAssetsAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformJsmExtraAssetsAriStaticOpts);
+    return new _PlatformJsmExtraAssetsAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformJsmExtraAssetsAriStaticOpts);
+    return new _PlatformJsmExtraAssetsAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/jsm-extra-conversations/types.ts
+var PlatformJsmExtraConversationsAriResourceOwner = "platform", PlatformJsmExtraConversationsAriResourceType = "jsm-extra-conversations";
+
+// src/platform/jsm-extra-conversations/manifest.ts
+var platformJsmExtraConversationsAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformJsmExtraConversationsAriResourceOwner,
+  resourceType: PlatformJsmExtraConversationsAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/jsm-extra-conversations/index.ts
+var PlatformJsmExtraConversationsAri = class _PlatformJsmExtraConversationsAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformJsmExtraConversationsAriStaticOpts.qualifier,
+      platformQualifier: platformJsmExtraConversationsAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformJsmExtraConversationsAriStaticOpts.resourceOwner,
+      resourceType: platformJsmExtraConversationsAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformJsmExtraConversationsAriStaticOpts);
+    return new _PlatformJsmExtraConversationsAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformJsmExtraConversationsAriStaticOpts);
+    return new _PlatformJsmExtraConversationsAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
 // src/platform/lifecycle-resource/types.ts
 var PlatformLifecycleResourceAriResourceOwner = "platform", PlatformLifecycleResourceAriResourceType = "lifecycle-resource";
 
 // src/platform/lifecycle-resource/manifest.ts
 var platformLifecycleResourceAriStaticOpts = {
   qualifier: "ari",
   platformQualifier: "cloud",
   cloudId: new RegExp("^$"),
-  // eslint-disable-line no-useless-escape
   resourceOwner: PlatformLifecycleResourceAriResourceOwner,
   resourceType: PlatformLifecycleResourceAriResourceType,
   resourceIdSlug: "{lifecycleResourceId}",
   resourceIdSegmentFormats: {
     lifecycleResourceId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
-    // eslint-disable-line no-useless-escape
   }
 };
 
 // src/platform/lifecycle-resource/index.ts
 var PlatformLifecycleResourceAri = class _PlatformLifecycleResourceAri extends RegisteredAri {
   constructor(opts) {
-    super(opts);
-    this._lifecycleResourceId = opts.resourceIdSegmentValues.lifecycleResourceId;
+    super(opts), this._lifecycleResourceId = opts.resourceIdSegmentValues.lifecycleResourceId;
   }
   get lifecycleResourceId() {
     return this._lifecycleResourceId;
   }
@@ -501,23 +1865,20 @@
 var platformLifecycleResourcePackageAriStaticOpts = {
   qualifier: "ari",
   platformQualifier: "cloud",
   cloudId: new RegExp("^$"),
-  // eslint-disable-line no-useless-escape
   resourceOwner: PlatformLifecycleResourcePackageAriResourceOwner,
   resourceType: PlatformLifecycleResourcePackageAriResourceType,
   resourceIdSlug: "{lifecycleResourcePackageId}",
   resourceIdSegmentFormats: {
     lifecycleResourcePackageId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
-    // eslint-disable-line no-useless-escape
   }
 };
 
 // src/platform/lifecycle-resource-package/index.ts
 var PlatformLifecycleResourcePackageAri = class _PlatformLifecycleResourcePackageAri extends RegisteredAri {
   constructor(opts) {
-    super(opts);
-    this._lifecycleResourcePackageId = opts.resourceIdSegmentValues.lifecycleResourcePackageId;
+    super(opts), this._lifecycleResourcePackageId = opts.resourceIdSegmentValues.lifecycleResourcePackageId;
   }
   get lifecycleResourcePackageId() {
     return this._lifecycleResourcePackageId;
   }
@@ -553,9 +1914,8 @@
 var platformLifecycleResourcePackageTypeAriStaticOpts = {
   qualifier: "ari",
   platformQualifier: "cloud",
   cloudId: new RegExp("^$"),
-  // eslint-disable-line no-useless-escape
   resourceOwner: PlatformLifecycleResourcePackageTypeAriResourceOwner,
   resourceType: PlatformLifecycleResourcePackageTypeAriResourceType,
   resourceIdSlug: "{resourcePackageTypeId}",
   resourceIdSegmentFormats: {
@@ -566,10 +1926,9 @@
 
 // src/platform/lifecycle-resource-package-type/index.ts
 var PlatformLifecycleResourcePackageTypeAri = class _PlatformLifecycleResourcePackageTypeAri extends RegisteredAri {
   constructor(opts) {
-    super(opts);
-    this._resourcePackageTypeId = opts.resourceIdSegmentValues.resourcePackageTypeId;
+    super(opts), this._resourcePackageTypeId = opts.resourceIdSegmentValues.resourcePackageTypeId;
   }
   get resourcePackageTypeId() {
     return this._resourcePackageTypeId;
   }
@@ -597,19 +1956,214 @@
     };
   }
 };
 
+// src/platform/loom/types.ts
+var PlatformLoomAriResourceOwner = "platform", PlatformLoomAriResourceType = "loom";
+
+// src/platform/loom/manifest.ts
+var platformLoomAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformLoomAriResourceOwner,
+  resourceType: PlatformLoomAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/loom/index.ts
+var PlatformLoomAri = class _PlatformLoomAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformLoomAriStaticOpts.qualifier,
+      platformQualifier: platformLoomAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformLoomAriStaticOpts.resourceOwner,
+      resourceType: platformLoomAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformLoomAriStaticOpts);
+    return new _PlatformLoomAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformLoomAriStaticOpts);
+    return new _PlatformLoomAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/mcp-tool/types.ts
+var PlatformMcpToolAriResourceOwner = "platform", PlatformMcpToolAriResourceType = "mcp-tool";
+
+// src/platform/mcp-tool/manifest.ts
+var platformMcpToolAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformMcpToolAriResourceOwner,
+  resourceType: PlatformMcpToolAriResourceType,
+  resourceIdSlug: "{toolUuid}",
+  resourceIdSegmentFormats: {
+    toolUuid: /[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}/
+  }
+};
+
+// src/platform/mcp-tool/index.ts
+var PlatformMcpToolAri = class _PlatformMcpToolAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._toolUuid = opts.resourceIdSegmentValues.toolUuid;
+  }
+  get toolUuid() {
+    return this._toolUuid;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformMcpToolAriStaticOpts.qualifier,
+      platformQualifier: platformMcpToolAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformMcpToolAriStaticOpts.resourceOwner,
+      resourceType: platformMcpToolAriStaticOpts.resourceType,
+      resourceId: `${opts.toolUuid}`,
+      resourceIdSegmentValues: {
+        toolUuid: opts.toolUuid
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformMcpToolAriStaticOpts);
+    return new _PlatformMcpToolAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformMcpToolAriStaticOpts);
+    return new _PlatformMcpToolAri(opts);
+  }
+  getVariables() {
+    return {
+      toolUuid: this.toolUuid
+    };
+  }
+};
+
+// src/platform/mercury/types.ts
+var PlatformMercuryAriResourceOwner = "platform", PlatformMercuryAriResourceType = "mercury";
+
+// src/platform/mercury/manifest.ts
+var platformMercuryAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformMercuryAriResourceOwner,
+  resourceType: PlatformMercuryAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/mercury/index.ts
+var PlatformMercuryAri = class _PlatformMercuryAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformMercuryAriStaticOpts.qualifier,
+      platformQualifier: platformMercuryAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformMercuryAriStaticOpts.resourceOwner,
+      resourceType: platformMercuryAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformMercuryAriStaticOpts);
+    return new _PlatformMercuryAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformMercuryAriStaticOpts);
+    return new _PlatformMercuryAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/opsgenie/types.ts
+var PlatformOpsgenieAriResourceOwner = "platform", PlatformOpsgenieAriResourceType = "opsgenie";
+
+// src/platform/opsgenie/manifest.ts
+var platformOpsgenieAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformOpsgenieAriResourceOwner,
+  resourceType: PlatformOpsgenieAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/opsgenie/index.ts
+var PlatformOpsgenieAri = class _PlatformOpsgenieAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformOpsgenieAriStaticOpts.qualifier,
+      platformQualifier: platformOpsgenieAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformOpsgenieAriStaticOpts.resourceOwner,
+      resourceType: platformOpsgenieAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformOpsgenieAriStaticOpts);
+    return new _PlatformOpsgenieAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformOpsgenieAriStaticOpts);
+    return new _PlatformOpsgenieAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
 // src/platform/org/types.ts
-var PlatformOrgAriResourceOwner = "platform", PlatformOrgAriResourceType = "org";
+var PlatformOrgAriResourceOwner = "platform";
 
 // src/platform/org/manifest.ts
 var platformOrgAriStaticOpts = {
   qualifier: "ari",
   platformQualifier: "cloud",
   cloudId: new RegExp("^$"),
-  // eslint-disable-line no-useless-escape
   resourceOwner: PlatformOrgAriResourceOwner,
-  resourceType: PlatformOrgAriResourceType,
+  resourceType: "org",
   resourceIdSlug: "{orgId}",
   resourceIdSegmentFormats: {
     orgId: /[a-zA-Z0-9\-]+/
     // eslint-disable-line no-useless-escape
@@ -618,10 +2172,9 @@
 
 // src/platform/org/index.ts
 var PlatformOrgAri = class _PlatformOrgAri extends RegisteredAri {
   constructor(opts) {
-    super(opts);
-    this._orgId = opts.resourceIdSegmentValues.orgId;
+    super(opts), this._orgId = opts.resourceIdSegmentValues.orgId;
   }
   get orgId() {
     return this._orgId;
   }
@@ -657,9 +2210,8 @@
 var platformOrgUserAriStaticOpts = {
   qualifier: "ari",
   platformQualifier: "cloud",
   cloudId: new RegExp("^$"),
-  // eslint-disable-line no-useless-escape
   resourceOwner: PlatformOrgUserAriResourceOwner,
   resourceType: PlatformOrgUserAriResourceType,
   resourceIdSlug: "{orgId}/{userId}",
   resourceIdSegmentFormats: {
@@ -672,10 +2224,9 @@
 
 // src/platform/org-user/index.ts
 var PlatformOrgUserAri = class _PlatformOrgUserAri extends RegisteredAri {
   constructor(opts) {
-    super(opts);
-    this._orgId = opts.resourceIdSegmentValues.orgId, this._userId = opts.resourceIdSegmentValues.userId;
+    super(opts), this._orgId = opts.resourceIdSegmentValues.orgId, this._userId = opts.resourceIdSegmentValues.userId;
   }
   get orgId() {
     return this._orgId;
   }
@@ -708,33 +2259,134 @@
     };
   }
 };
 
+// src/platform/organization-classification-history/types.ts
+var PlatformOrganizationClassificationHistoryAriResourceOwner = "platform", PlatformOrganizationClassificationHistoryAriResourceType = "organization-classification-history";
+
+// src/platform/organization-classification-history/manifest.ts
+var platformOrganizationClassificationHistoryAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformOrganizationClassificationHistoryAriResourceOwner,
+  resourceType: PlatformOrganizationClassificationHistoryAriResourceType,
+  resourceIdSlug: "{orgId}/{updateSequenceNumber}",
+  resourceIdSegmentFormats: {
+    orgId: /[a-zA-Z0-9\-]+/,
+    // eslint-disable-line no-useless-escape
+    updateSequenceNumber: /\d+/
+  }
+};
+
+// src/platform/organization-classification-history/index.ts
+var PlatformOrganizationClassificationHistoryAri = class _PlatformOrganizationClassificationHistoryAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._orgId = opts.resourceIdSegmentValues.orgId, this._updateSequenceNumber = opts.resourceIdSegmentValues.updateSequenceNumber;
+  }
+  get orgId() {
+    return this._orgId;
+  }
+  get updateSequenceNumber() {
+    return this._updateSequenceNumber;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformOrganizationClassificationHistoryAriStaticOpts.qualifier,
+      platformQualifier: platformOrganizationClassificationHistoryAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformOrganizationClassificationHistoryAriStaticOpts.resourceOwner,
+      resourceType: platformOrganizationClassificationHistoryAriStaticOpts.resourceType,
+      resourceId: `${opts.orgId}/${opts.updateSequenceNumber}`,
+      resourceIdSegmentValues: {
+        orgId: opts.orgId,
+        updateSequenceNumber: opts.updateSequenceNumber
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformOrganizationClassificationHistoryAriStaticOpts);
+    return new _PlatformOrganizationClassificationHistoryAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformOrganizationClassificationHistoryAriStaticOpts);
+    return new _PlatformOrganizationClassificationHistoryAri(opts);
+  }
+  getVariables() {
+    return {
+      orgId: this.orgId,
+      updateSequenceNumber: this.updateSequenceNumber
+    };
+  }
+};
+
+// src/platform/passionfruit/types.ts
+var PlatformPassionfruitAriResourceOwner = "platform", PlatformPassionfruitAriResourceType = "passionfruit";
+
+// src/platform/passionfruit/manifest.ts
+var platformPassionfruitAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformPassionfruitAriResourceOwner,
+  resourceType: PlatformPassionfruitAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/passionfruit/index.ts
+var PlatformPassionfruitAri = class _PlatformPassionfruitAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformPassionfruitAriStaticOpts.qualifier,
+      platformQualifier: platformPassionfruitAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformPassionfruitAriStaticOpts.resourceOwner,
+      resourceType: platformPassionfruitAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformPassionfruitAriStaticOpts);
+    return new _PlatformPassionfruitAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformPassionfruitAriStaticOpts);
+    return new _PlatformPassionfruitAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
 // src/platform/product/types.ts
 var PlatformProductAriResourceOwner = "platform", PlatformProductAriResourceType = "product";
 
 // src/platform/product/manifest.ts
 var platformProductAriStaticOpts = {
   qualifier: "ari",
   platformQualifier: "cloud",
   cloudId: new RegExp("^$"),
-  // eslint-disable-line no-useless-escape
   resourceOwner: PlatformProductAriResourceOwner,
   resourceType: PlatformProductAriResourceType,
   resourceIdSlug: "{integrationKey}/{productKey}",
   resourceIdSegmentFormats: {
     integrationKey: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/,
-    // eslint-disable-line no-useless-escape
     productKey: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
-    // eslint-disable-line no-useless-escape
   }
 };
 
 // src/platform/product/index.ts
 var PlatformProductAri = class _PlatformProductAri extends RegisteredAri {
   constructor(opts) {
-    super(opts);
-    this._integrationKey = opts.resourceIdSegmentValues.integrationKey, this._productKey = opts.resourceIdSegmentValues.productKey;
+    super(opts), this._integrationKey = opts.resourceIdSegmentValues.integrationKey, this._productKey = opts.resourceIdSegmentValues.productKey;
   }
   get integrationKey() {
     return this._integrationKey;
   }
@@ -767,31 +2419,281 @@
     };
   }
 };
 
+// src/platform/product-collaboration-context-connection/types.ts
+var PlatformProductCollaborationContextConnectionAriResourceOwner = "platform", PlatformProductCollaborationContextConnectionAriResourceType = "product-collaboration-context-connection";
+
+// src/platform/product-collaboration-context-connection/manifest.ts
+var platformProductCollaborationContextConnectionAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformProductCollaborationContextConnectionAriResourceOwner,
+  resourceType: PlatformProductCollaborationContextConnectionAriResourceType,
+  resourceIdSlug: "collaboration-context/{collaborationContextId}/{productCollaborationContextConnectionId}",
+  resourceIdSegmentFormats: {
+    collaborationContextId: /[a-zA-Z0-9\-]+/,
+    // eslint-disable-line no-useless-escape
+    productCollaborationContextConnectionId: /[a-zA-Z0-9\-]+/
+    // eslint-disable-line no-useless-escape
+  }
+};
+
+// src/platform/product-collaboration-context-connection/index.ts
+var PlatformProductCollaborationContextConnectionAri = class _PlatformProductCollaborationContextConnectionAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._collaborationContextId = opts.resourceIdSegmentValues.collaborationContextId, this._productCollaborationContextConnectionId = opts.resourceIdSegmentValues.productCollaborationContextConnectionId;
+  }
+  get collaborationContextId() {
+    return this._collaborationContextId;
+  }
+  get productCollaborationContextConnectionId() {
+    return this._productCollaborationContextConnectionId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformProductCollaborationContextConnectionAriStaticOpts.qualifier,
+      platformQualifier: platformProductCollaborationContextConnectionAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformProductCollaborationContextConnectionAriStaticOpts.resourceOwner,
+      resourceType: platformProductCollaborationContextConnectionAriStaticOpts.resourceType,
+      resourceId: `collaboration-context/${opts.collaborationContextId}/${opts.productCollaborationContextConnectionId}`,
+      resourceIdSegmentValues: {
+        collaborationContextId: opts.collaborationContextId,
+        productCollaborationContextConnectionId: opts.productCollaborationContextConnectionId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformProductCollaborationContextConnectionAriStaticOpts);
+    return new _PlatformProductCollaborationContextConnectionAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformProductCollaborationContextConnectionAriStaticOpts);
+    return new _PlatformProductCollaborationContextConnectionAri(opts);
+  }
+  getVariables() {
+    return {
+      collaborationContextId: this.collaborationContextId,
+      productCollaborationContextConnectionId: this.productCollaborationContextConnectionId
+    };
+  }
+};
+
+// src/platform/project/types.ts
+var PlatformProjectAriResourceOwner = "platform", PlatformProjectAriResourceType = "project";
+
+// src/platform/project/manifest.ts
+var platformProjectAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformProjectAriResourceOwner,
+  resourceType: PlatformProjectAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/project/index.ts
+var PlatformProjectAri = class _PlatformProjectAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformProjectAriStaticOpts.qualifier,
+      platformQualifier: platformProjectAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformProjectAriStaticOpts.resourceOwner,
+      resourceType: platformProjectAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformProjectAriStaticOpts);
+    return new _PlatformProjectAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformProjectAriStaticOpts);
+    return new _PlatformProjectAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/radar/types.ts
+var PlatformRadarAriResourceOwner = "platform", PlatformRadarAriResourceType = "radar";
+
+// src/platform/radar/manifest.ts
+var platformRadarAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformRadarAriResourceOwner,
+  resourceType: PlatformRadarAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/radar/index.ts
+var PlatformRadarAri = class _PlatformRadarAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformRadarAriStaticOpts.qualifier,
+      platformQualifier: platformRadarAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformRadarAriStaticOpts.resourceOwner,
+      resourceType: platformRadarAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformRadarAriStaticOpts);
+    return new _PlatformRadarAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformRadarAriStaticOpts);
+    return new _PlatformRadarAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/rovo/types.ts
+var PlatformRovoAriResourceOwner = "platform", PlatformRovoAriResourceType = "rovo";
+
+// src/platform/rovo/manifest.ts
+var platformRovoAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformRovoAriResourceOwner,
+  resourceType: PlatformRovoAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/rovo/index.ts
+var PlatformRovoAri = class _PlatformRovoAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformRovoAriStaticOpts.qualifier,
+      platformQualifier: platformRovoAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformRovoAriStaticOpts.resourceOwner,
+      resourceType: platformRovoAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformRovoAriStaticOpts);
+    return new _PlatformRovoAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformRovoAriStaticOpts);
+    return new _PlatformRovoAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/rovo-instance/types.ts
+var PlatformRovoInstanceAriResourceOwner = "platform", PlatformRovoInstanceAriResourceType = "rovo-instance";
+
+// src/platform/rovo-instance/manifest.ts
+var platformRovoInstanceAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformRovoInstanceAriResourceOwner,
+  resourceType: PlatformRovoInstanceAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/rovo-instance/index.ts
+var PlatformRovoInstanceAri = class _PlatformRovoInstanceAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformRovoInstanceAriStaticOpts.qualifier,
+      platformQualifier: platformRovoInstanceAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformRovoInstanceAriStaticOpts.resourceOwner,
+      resourceType: platformRovoInstanceAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformRovoInstanceAriStaticOpts);
+    return new _PlatformRovoInstanceAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformRovoInstanceAriStaticOpts);
+    return new _PlatformRovoInstanceAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
 // src/platform/secure-tunnel/types.ts
 var PlatformSecureTunnelAriResourceOwner = "platform", PlatformSecureTunnelAriResourceType = "secure-tunnel";
 
 // src/platform/secure-tunnel/manifest.ts
 var platformSecureTunnelAriStaticOpts = {
   qualifier: "ari",
   platformQualifier: "cloud",
   cloudId: new RegExp("^$"),
-  // eslint-disable-line no-useless-escape
   resourceOwner: PlatformSecureTunnelAriResourceOwner,
   resourceType: PlatformSecureTunnelAriResourceType,
   resourceIdSlug: "{secureTunnelId}",
   resourceIdSegmentFormats: {
     secureTunnelId: /[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}/
-    // eslint-disable-line no-useless-escape
   }
 };
 
 // src/platform/secure-tunnel/index.ts
 var PlatformSecureTunnelAri = class _PlatformSecureTunnelAri extends RegisteredAri {
   constructor(opts) {
-    super(opts);
-    this._secureTunnelId = opts.resourceIdSegmentValues.secureTunnelId;
+    super(opts), this._secureTunnelId = opts.resourceIdSegmentValues.secureTunnelId;
   }
   get secureTunnelId() {
     return this._secureTunnelId;
   }
@@ -827,23 +2729,20 @@
 var platformSiteAriStaticOpts = {
   qualifier: "ari",
   platformQualifier: "cloud",
   cloudId: new RegExp("^$"),
-  // eslint-disable-line no-useless-escape
   resourceOwner: PlatformSiteAriResourceOwner,
   resourceType: PlatformSiteAriResourceType,
   resourceIdSlug: "{siteId}",
   resourceIdSegmentFormats: {
     siteId: /[a-zA-Z0-9_\-.]{1,255}/
-    // eslint-disable-line no-useless-escape
   }
 };
 
 // src/platform/site/index.ts
 var PlatformSiteAri = class _PlatformSiteAri extends RegisteredAri {
   constructor(opts) {
-    super(opts);
-    this._siteId = opts.resourceIdSegmentValues.siteId;
+    super(opts), this._siteId = opts.resourceIdSegmentValues.siteId;
   }
   get siteId() {
     return this._siteId;
   }
@@ -871,31 +2770,224 @@
     };
   }
 };
 
+// src/platform/statuspage-page/types.ts
+var PlatformStatuspagePageAriResourceOwner = "platform", PlatformStatuspagePageAriResourceType = "statuspage-page";
+
+// src/platform/statuspage-page/manifest.ts
+var platformStatuspagePageAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformStatuspagePageAriResourceOwner,
+  resourceType: PlatformStatuspagePageAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/statuspage-page/index.ts
+var PlatformStatuspagePageAri = class _PlatformStatuspagePageAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformStatuspagePageAriStaticOpts.qualifier,
+      platformQualifier: platformStatuspagePageAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformStatuspagePageAriStaticOpts.resourceOwner,
+      resourceType: platformStatuspagePageAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformStatuspagePageAriStaticOpts);
+    return new _PlatformStatuspagePageAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformStatuspagePageAriStaticOpts);
+    return new _PlatformStatuspagePageAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/statuspage-product/types.ts
+var PlatformStatuspageProductAriResourceOwner = "platform", PlatformStatuspageProductAriResourceType = "statuspage-product";
+
+// src/platform/statuspage-product/manifest.ts
+var platformStatuspageProductAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformStatuspageProductAriResourceOwner,
+  resourceType: PlatformStatuspageProductAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/statuspage-product/index.ts
+var PlatformStatuspageProductAri = class _PlatformStatuspageProductAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformStatuspageProductAriStaticOpts.qualifier,
+      platformQualifier: platformStatuspageProductAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformStatuspageProductAriStaticOpts.resourceOwner,
+      resourceType: platformStatuspageProductAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformStatuspageProductAriStaticOpts);
+    return new _PlatformStatuspageProductAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformStatuspageProductAriStaticOpts);
+    return new _PlatformStatuspageProductAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/synthetic/types.ts
+var PlatformSyntheticAriResourceOwner = "platform", PlatformSyntheticAriResourceType = "synthetic";
+
+// src/platform/synthetic/manifest.ts
+var platformSyntheticAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformSyntheticAriResourceOwner,
+  resourceType: PlatformSyntheticAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/synthetic/index.ts
+var PlatformSyntheticAri = class _PlatformSyntheticAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformSyntheticAriStaticOpts.qualifier,
+      platformQualifier: platformSyntheticAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformSyntheticAriStaticOpts.resourceOwner,
+      resourceType: platformSyntheticAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformSyntheticAriStaticOpts);
+    return new _PlatformSyntheticAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformSyntheticAriStaticOpts);
+    return new _PlatformSyntheticAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/synthetic-a/types.ts
+var PlatformSyntheticAAriResourceOwner = "platform", PlatformSyntheticAAriResourceType = "synthetic-a";
+
+// src/platform/synthetic-a/manifest.ts
+var platformSyntheticAAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformSyntheticAAriResourceOwner,
+  resourceType: PlatformSyntheticAAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/synthetic-a/index.ts
+var PlatformSyntheticAAri = class _PlatformSyntheticAAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformSyntheticAAriStaticOpts.qualifier,
+      platformQualifier: platformSyntheticAAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformSyntheticAAriStaticOpts.resourceOwner,
+      resourceType: platformSyntheticAAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformSyntheticAAriStaticOpts);
+    return new _PlatformSyntheticAAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformSyntheticAAriStaticOpts);
+    return new _PlatformSyntheticAAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
 // src/platform/test-provisioning-entity/types.ts
 var PlatformTestProvisioningEntityAriResourceOwner = "platform", PlatformTestProvisioningEntityAriResourceType = "test-provisioning-entity";
 
 // src/platform/test-provisioning-entity/manifest.ts
 var platformTestProvisioningEntityAriStaticOpts = {
   qualifier: "ari",
   platformQualifier: "cloud",
   cloudId: new RegExp("^$"),
-  // eslint-disable-line no-useless-escape
   resourceOwner: PlatformTestProvisioningEntityAriResourceOwner,
   resourceType: PlatformTestProvisioningEntityAriResourceType,
   resourceIdSlug: "{testEntityId}",
   resourceIdSegmentFormats: {
     testEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
-    // eslint-disable-line no-useless-escape
   }
 };
 
 // src/platform/test-provisioning-entity/index.ts
 var PlatformTestProvisioningEntityAri = class _PlatformTestProvisioningEntityAri extends RegisteredAri {
   constructor(opts) {
-    super(opts);
-    this._testEntityId = opts.resourceIdSegmentValues.testEntityId;
+    super(opts), this._testEntityId = opts.resourceIdSegmentValues.testEntityId;
   }
   get testEntityId() {
     return this._testEntityId;
   }
@@ -922,19 +3014,212 @@
       testEntityId: this.testEntityId
     };
   }
 };
+
+// src/platform/townsquare/types.ts
+var PlatformTownsquareAriResourceOwner = "platform", PlatformTownsquareAriResourceType = "townsquare";
+
+// src/platform/townsquare/manifest.ts
+var platformTownsquareAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformTownsquareAriResourceOwner,
+  resourceType: PlatformTownsquareAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/townsquare/index.ts
+var PlatformTownsquareAri = class _PlatformTownsquareAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformTownsquareAriStaticOpts.qualifier,
+      platformQualifier: platformTownsquareAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformTownsquareAriStaticOpts.resourceOwner,
+      resourceType: platformTownsquareAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformTownsquareAriStaticOpts);
+    return new _PlatformTownsquareAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformTownsquareAriStaticOpts);
+    return new _PlatformTownsquareAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/unified-help/types.ts
+var PlatformUnifiedHelpAriResourceOwner = "platform", PlatformUnifiedHelpAriResourceType = "unified-help";
+
+// src/platform/unified-help/manifest.ts
+var platformUnifiedHelpAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformUnifiedHelpAriResourceOwner,
+  resourceType: PlatformUnifiedHelpAriResourceType,
+  resourceIdSlug: "{productEntityId}",
+  resourceIdSegmentFormats: {
+    productEntityId: /[!a-zA-Z0-9\-_.~@:;{}=]+(\/[!a-zA-Z0-9\-_.~@:;{}=]+)*/
+  }
+};
+
+// src/platform/unified-help/index.ts
+var PlatformUnifiedHelpAri = class _PlatformUnifiedHelpAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._productEntityId = opts.resourceIdSegmentValues.productEntityId;
+  }
+  get productEntityId() {
+    return this._productEntityId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformUnifiedHelpAriStaticOpts.qualifier,
+      platformQualifier: platformUnifiedHelpAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformUnifiedHelpAriStaticOpts.resourceOwner,
+      resourceType: platformUnifiedHelpAriStaticOpts.resourceType,
+      resourceId: `${opts.productEntityId}`,
+      resourceIdSegmentValues: {
+        productEntityId: opts.productEntityId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformUnifiedHelpAriStaticOpts);
+    return new _PlatformUnifiedHelpAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformUnifiedHelpAriStaticOpts);
+    return new _PlatformUnifiedHelpAri(opts);
+  }
+  getVariables() {
+    return {
+      productEntityId: this.productEntityId
+    };
+  }
+};
+
+// src/platform/unit/types.ts
+var PlatformUnitAriResourceOwner = "platform", PlatformUnitAriResourceType = "unit";
+
+// src/platform/unit/manifest.ts
+var platformUnitAriStaticOpts = {
+  qualifier: "ari",
+  platformQualifier: "cloud",
+  cloudId: new RegExp("^$"),
+  resourceOwner: PlatformUnitAriResourceOwner,
+  resourceType: PlatformUnitAriResourceType,
+  resourceIdSlug: "{unitId}",
+  resourceIdSegmentFormats: {
+    unitId: /[a-zA-Z0-9\-]+/
+    // eslint-disable-line no-useless-escape
+  }
+};
+
+// src/platform/unit/index.ts
+var PlatformUnitAri = class _PlatformUnitAri extends RegisteredAri {
+  constructor(opts) {
+    super(opts), this._unitId = opts.resourceIdSegmentValues.unitId;
+  }
+  get unitId() {
+    return this._unitId;
+  }
+  static create(opts) {
+    let derivedOpts = {
+      qualifier: platformUnitAriStaticOpts.qualifier,
+      platformQualifier: platformUnitAriStaticOpts.platformQualifier,
+      cloudId: void 0,
+      resourceOwner: platformUnitAriStaticOpts.resourceOwner,
+      resourceType: platformUnitAriStaticOpts.resourceType,
+      resourceId: `${opts.unitId}`,
+      resourceIdSegmentValues: {
+        unitId: opts.unitId
+      }
+    }, ariOpts = AriParser.fromOpts(derivedOpts, platformUnitAriStaticOpts);
+    return new _PlatformUnitAri(ariOpts);
+  }
+  static parse(maybeAri) {
+    let opts = AriParser.fromString(maybeAri, platformUnitAriStaticOpts);
+    return new _PlatformUnitAri(opts);
+  }
+  getVariables() {
+    return {
+      unitId: this.unitId
+    };
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  PlatformAccessAri,
+  PlatformActionAri,
+  PlatformAppAri,
+  PlatformAssetsAri,
+  PlatformAtlassianAnalyticsAri,
+  PlatformBeaconAri,
+  PlatformCanvasAri,
   PlatformClassificationTagAri,
   PlatformCollaborationContextAri,
+  PlatformCompassAri,
+  PlatformConfluenceAri,
+  PlatformCustomEmailFooterAri,
+  PlatformDevaiAri,
+  PlatformEcosystemAppAri,
+  PlatformEnterpriseAppAri,
+  PlatformEnterpriseConfluenceAri,
+  PlatformEnterpriseJiraServicedeskAri,
+  PlatformEnterpriseJiraSoftwareAri,
+  PlatformGoalAri,
+  PlatformGuardPremiumAri,
+  PlatformGuardPremiumInstanceAri,
   PlatformIntegrationAri,
+  PlatformJiraAlignAri,
+  PlatformJiraCoreAri,
+  PlatformJiraCustomerServiceAri,
+  PlatformJiraProductDiscoveryAri,
+  PlatformJiraServicedeskAri,
+  PlatformJiraSoftwareAri,
+  PlatformJsmExtraAssetsAri,
+  PlatformJsmExtraConversationsAri,
   PlatformLifecycleResourceAri,
   PlatformLifecycleResourcePackageAri,
   PlatformLifecycleResourcePackageTypeAri,
+  PlatformLoomAri,
+  PlatformMcpToolAri,
+  PlatformMercuryAri,
+  PlatformOpsgenieAri,
   PlatformOrgAri,
   PlatformOrgUserAri,
+  PlatformOrganizationClassificationHistoryAri,
+  PlatformPassionfruitAri,
   PlatformProductAri,
+  PlatformProductCollaborationContextConnectionAri,
+  PlatformProjectAri,
+  PlatformRadarAri,
+  PlatformRovoAri,
+  PlatformRovoInstanceAri,
   PlatformSecureTunnelAri,
   PlatformSiteAri,
-  PlatformTestProvisioningEntityAri
+  PlatformStatuspagePageAri,
+  PlatformStatuspageProductAri,
+  PlatformSyntheticAAri,
+  PlatformSyntheticAri,
+  PlatformTestProvisioningEntityAri,
+  PlatformTownsquareAri,
+  PlatformUnifiedHelpAri,
+  PlatformUnitAri
 });