npm package diff
Package: @forge/util
Versions: 1.4.10-next.0 - 1.4.10-next.0-experimental-effab31
File: package/packages/ari/trello/index.js
Index: package/packages/ari/trello/index.js
===================================================================
--- package/packages/ari/trello/index.js
+++ package/packages/ari/trello/index.js
@@ -17,14 +17,26 @@
// src/trello/index.ts
var trello_exports = {};
__export(trello_exports, {
TrelloAttachmentAri: () => TrelloAttachmentAri,
+ TrelloAvatarAri: () => TrelloAvatarAri,
+ TrelloBackgroundAri: () => TrelloBackgroundAri,
TrelloBoardAri: () => TrelloBoardAri,
TrelloCardAri: () => TrelloCardAri,
+ TrelloCheckItemAri: () => TrelloCheckItemAri,
+ TrelloChecklistAri: () => TrelloChecklistAri,
+ TrelloCustomFieldAri: () => TrelloCustomFieldAri,
+ TrelloEmojiAri: () => TrelloEmojiAri,
TrelloEnterpriseAri: () => TrelloEnterpriseAri,
+ TrelloLabelAri: () => TrelloLabelAri,
TrelloListAri: () => TrelloListAri,
+ TrelloLogoAri: () => TrelloLogoAri,
+ TrelloPlannerAri: () => TrelloPlannerAri,
+ TrelloPlannerCalendarAri: () => TrelloPlannerCalendarAri,
+ TrelloPlannerEventCardAri: () => TrelloPlannerEventCardAri,
TrelloRoleAri: () => TrelloRoleAri,
TrelloSiteAri: () => TrelloSiteAri,
+ TrelloStickerAri: () => TrelloStickerAri,
TrelloUserAri: () => TrelloUserAri,
TrelloWorkspaceAri: () => TrelloWorkspaceAri
});
module.exports = __toCommonJS(trello_exports);
@@ -33,9 +45,9 @@
var ValidationError = class extends Error {
};
// src/core/rules/cloud-id.ts
-function validateCloudId(cloudId, format = new RegExp("^[a-zA-Z0-9\\-]*$")) {
+function validateCloudId(cloudId, format = new RegExp("^[a-zA-Z0-9_\\-.]{0,255}$")) {
if (!cloudId.match(format))
throw new ValidationError(`Invalid cloud ID, expected ID of format ${format}.`);
}
@@ -55,9 +67,9 @@
throw new ValidationError(`ARI must have a qualifier of 'ari'. Received: ${qualifier}`);
}
// src/core/rules/resource-id.ts
-function validateResourceId(id, format = new RegExp("[!a-zA-Z0-9\\-_.~@:{}=]+(/[!a-zA-Z0-9\\-_.~@:{}=]+)*" /* ANY_RESOURCE_ID */), key = "resourceId") {
+function validateResourceId(id, format = new RegExp("[!a-zA-Z0-9\\-_.~@:;{}=]+(/[!a-zA-Z0-9\\-_.~@:;{}=]+)*" /* ANY_RESOURCE_ID */), key = "resourceId") {
let formatWithCarets = new RegExp(`^${format.source}$`);
if (!id.match(formatWithCarets))
throw new ValidationError(`Invalid ${key} - ${id}, expected ID of format ${formatWithCarets}.`);
}
@@ -290,8 +302,9 @@
var trelloAttachmentAriStaticOpts = {
qualifier: "ari",
platformQualifier: "cloud",
cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
resourceOwner: TrelloAttachmentAriResourceOwner,
resourceType: TrelloAttachmentAriResourceType,
resourceIdSlug: "card/workspace/{workspaceId}/{cardId}/{attachmentId}",
resourceIdSegmentFormats: {
@@ -347,16 +360,142 @@
};
}
};
+// src/trello/avatar/types.ts
+var TrelloAvatarAriResourceOwner = "trello", TrelloAvatarAriResourceType = "avatar";
+
+// src/trello/avatar/manifest.ts
+var trelloAvatarAriStaticOpts = {
+ qualifier: "ari",
+ platformQualifier: "cloud",
+ cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
+ resourceOwner: TrelloAvatarAriResourceOwner,
+ resourceType: TrelloAvatarAriResourceType,
+ resourceIdSlug: "member/{memberId}/{avatarHash}",
+ resourceIdSegmentFormats: {
+ memberId: /[a-zA-Z0-9\-_.]*/,
+ // eslint-disable-line no-useless-escape
+ avatarHash: /[a-zA-Z0-9\-_.]*/
+ // eslint-disable-line no-useless-escape
+ }
+};
+
+// src/trello/avatar/index.ts
+var TrelloAvatarAri = class _TrelloAvatarAri extends RegisteredAri {
+ constructor(opts) {
+ super(opts);
+ this._memberId = opts.resourceIdSegmentValues.memberId, this._avatarHash = opts.resourceIdSegmentValues.avatarHash;
+ }
+ get memberId() {
+ return this._memberId;
+ }
+ get avatarHash() {
+ return this._avatarHash;
+ }
+ static create(opts) {
+ let derivedOpts = {
+ qualifier: trelloAvatarAriStaticOpts.qualifier,
+ platformQualifier: trelloAvatarAriStaticOpts.platformQualifier,
+ cloudId: void 0,
+ resourceOwner: trelloAvatarAriStaticOpts.resourceOwner,
+ resourceType: trelloAvatarAriStaticOpts.resourceType,
+ resourceId: `member/${opts.memberId}/${opts.avatarHash}`,
+ resourceIdSegmentValues: {
+ memberId: opts.memberId || "",
+ avatarHash: opts.avatarHash || ""
+ }
+ }, ariOpts = AriParser.fromOpts(derivedOpts, trelloAvatarAriStaticOpts);
+ return new _TrelloAvatarAri(ariOpts);
+ }
+ static parse(maybeAri) {
+ let opts = AriParser.fromString(maybeAri, trelloAvatarAriStaticOpts);
+ return new _TrelloAvatarAri(opts);
+ }
+ getVariables() {
+ return {
+ memberId: this.memberId,
+ avatarHash: this.avatarHash
+ };
+ }
+};
+
+// src/trello/background/types.ts
+var TrelloBackgroundAriResourceOwner = "trello", TrelloBackgroundAriResourceType = "background";
+
+// src/trello/background/manifest.ts
+var trelloBackgroundAriStaticOpts = {
+ qualifier: "ari",
+ platformQualifier: "cloud",
+ cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
+ resourceOwner: TrelloBackgroundAriResourceOwner,
+ resourceType: TrelloBackgroundAriResourceType,
+ resourceIdSlug: "type-id/background-type/{backgroundType}/{typeId}/{backgroundId}",
+ resourceIdSegmentFormats: {
+ backgroundType: /(?:member|board|shared)/,
+ // eslint-disable-line no-useless-escape
+ typeId: /[a-zA-Z0-9\-_.]*/,
+ // eslint-disable-line no-useless-escape
+ backgroundId: /[a-zA-Z0-9\-_.]*/
+ // eslint-disable-line no-useless-escape
+ }
+};
+
+// src/trello/background/index.ts
+var TrelloBackgroundAri = class _TrelloBackgroundAri extends RegisteredAri {
+ constructor(opts) {
+ super(opts);
+ this._backgroundType = opts.resourceIdSegmentValues.backgroundType, this._typeId = opts.resourceIdSegmentValues.typeId, this._backgroundId = opts.resourceIdSegmentValues.backgroundId;
+ }
+ get backgroundType() {
+ return this._backgroundType;
+ }
+ get typeId() {
+ return this._typeId;
+ }
+ get backgroundId() {
+ return this._backgroundId;
+ }
+ static create(opts) {
+ let derivedOpts = {
+ qualifier: trelloBackgroundAriStaticOpts.qualifier,
+ platformQualifier: trelloBackgroundAriStaticOpts.platformQualifier,
+ cloudId: void 0,
+ resourceOwner: trelloBackgroundAriStaticOpts.resourceOwner,
+ resourceType: trelloBackgroundAriStaticOpts.resourceType,
+ resourceId: `type-id/background-type/${opts.backgroundType}/${opts.typeId}/${opts.backgroundId}`,
+ resourceIdSegmentValues: {
+ backgroundType: opts.backgroundType,
+ typeId: opts.typeId || "",
+ backgroundId: opts.backgroundId || ""
+ }
+ }, ariOpts = AriParser.fromOpts(derivedOpts, trelloBackgroundAriStaticOpts);
+ return new _TrelloBackgroundAri(ariOpts);
+ }
+ static parse(maybeAri) {
+ let opts = AriParser.fromString(maybeAri, trelloBackgroundAriStaticOpts);
+ return new _TrelloBackgroundAri(opts);
+ }
+ getVariables() {
+ return {
+ backgroundType: this.backgroundType,
+ typeId: this.typeId,
+ backgroundId: this.backgroundId
+ };
+ }
+};
+
// src/trello/board/types.ts
var TrelloBoardAriResourceOwner = "trello", TrelloBoardAriResourceType = "board";
// src/trello/board/manifest.ts
var trelloBoardAriStaticOpts = {
qualifier: "ari",
platformQualifier: "cloud",
cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
resourceOwner: TrelloBoardAriResourceOwner,
resourceType: TrelloBoardAriResourceType,
resourceIdSlug: "workspace/{workspaceId}/{boardId}",
resourceIdSegmentFormats: {
@@ -413,8 +552,9 @@
var trelloCardAriStaticOpts = {
qualifier: "ari",
platformQualifier: "cloud",
cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
resourceOwner: TrelloCardAriResourceOwner,
resourceType: TrelloCardAriResourceType,
resourceIdSlug: "workspace/{workspaceId}/{cardId}",
resourceIdSegmentFormats: {
@@ -463,16 +603,246 @@
};
}
};
+// src/trello/check-item/types.ts
+var TrelloCheckItemAriResourceOwner = "trello", TrelloCheckItemAriResourceType = "check-item";
+
+// src/trello/check-item/manifest.ts
+var trelloCheckItemAriStaticOpts = {
+ qualifier: "ari",
+ platformQualifier: "cloud",
+ cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
+ resourceOwner: TrelloCheckItemAriResourceOwner,
+ resourceType: TrelloCheckItemAriResourceType,
+ resourceIdSlug: "workspace/{workspaceId}/{checkItemId}",
+ resourceIdSegmentFormats: {
+ workspaceId: /[a-zA-Z0-9\-_.]*/,
+ // eslint-disable-line no-useless-escape
+ checkItemId: /[a-zA-Z0-9\-_.]*/
+ // eslint-disable-line no-useless-escape
+ }
+};
+
+// src/trello/check-item/index.ts
+var TrelloCheckItemAri = class _TrelloCheckItemAri extends RegisteredAri {
+ constructor(opts) {
+ super(opts);
+ this._workspaceId = opts.resourceIdSegmentValues.workspaceId, this._checkItemId = opts.resourceIdSegmentValues.checkItemId;
+ }
+ get workspaceId() {
+ return this._workspaceId;
+ }
+ get checkItemId() {
+ return this._checkItemId;
+ }
+ static create(opts) {
+ let derivedOpts = {
+ qualifier: trelloCheckItemAriStaticOpts.qualifier,
+ platformQualifier: trelloCheckItemAriStaticOpts.platformQualifier,
+ cloudId: void 0,
+ resourceOwner: trelloCheckItemAriStaticOpts.resourceOwner,
+ resourceType: trelloCheckItemAriStaticOpts.resourceType,
+ resourceId: `workspace/${opts.workspaceId}/${opts.checkItemId}`,
+ resourceIdSegmentValues: {
+ workspaceId: opts.workspaceId || "",
+ checkItemId: opts.checkItemId || ""
+ }
+ }, ariOpts = AriParser.fromOpts(derivedOpts, trelloCheckItemAriStaticOpts);
+ return new _TrelloCheckItemAri(ariOpts);
+ }
+ static parse(maybeAri) {
+ let opts = AriParser.fromString(maybeAri, trelloCheckItemAriStaticOpts);
+ return new _TrelloCheckItemAri(opts);
+ }
+ getVariables() {
+ return {
+ workspaceId: this.workspaceId,
+ checkItemId: this.checkItemId
+ };
+ }
+};
+
+// src/trello/checklist/types.ts
+var TrelloChecklistAriResourceOwner = "trello", TrelloChecklistAriResourceType = "checklist";
+
+// src/trello/checklist/manifest.ts
+var trelloChecklistAriStaticOpts = {
+ qualifier: "ari",
+ platformQualifier: "cloud",
+ cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
+ resourceOwner: TrelloChecklistAriResourceOwner,
+ resourceType: TrelloChecklistAriResourceType,
+ resourceIdSlug: "workspace/{workspaceId}/{checklistId}",
+ resourceIdSegmentFormats: {
+ workspaceId: /[a-zA-Z0-9\-_.]*/,
+ // eslint-disable-line no-useless-escape
+ checklistId: /[a-zA-Z0-9\-_.]*/
+ // eslint-disable-line no-useless-escape
+ }
+};
+
+// src/trello/checklist/index.ts
+var TrelloChecklistAri = class _TrelloChecklistAri extends RegisteredAri {
+ constructor(opts) {
+ super(opts);
+ this._workspaceId = opts.resourceIdSegmentValues.workspaceId, this._checklistId = opts.resourceIdSegmentValues.checklistId;
+ }
+ get workspaceId() {
+ return this._workspaceId;
+ }
+ get checklistId() {
+ return this._checklistId;
+ }
+ static create(opts) {
+ let derivedOpts = {
+ qualifier: trelloChecklistAriStaticOpts.qualifier,
+ platformQualifier: trelloChecklistAriStaticOpts.platformQualifier,
+ cloudId: void 0,
+ resourceOwner: trelloChecklistAriStaticOpts.resourceOwner,
+ resourceType: trelloChecklistAriStaticOpts.resourceType,
+ resourceId: `workspace/${opts.workspaceId}/${opts.checklistId}`,
+ resourceIdSegmentValues: {
+ workspaceId: opts.workspaceId || "",
+ checklistId: opts.checklistId || ""
+ }
+ }, ariOpts = AriParser.fromOpts(derivedOpts, trelloChecklistAriStaticOpts);
+ return new _TrelloChecklistAri(ariOpts);
+ }
+ static parse(maybeAri) {
+ let opts = AriParser.fromString(maybeAri, trelloChecklistAriStaticOpts);
+ return new _TrelloChecklistAri(opts);
+ }
+ getVariables() {
+ return {
+ workspaceId: this.workspaceId,
+ checklistId: this.checklistId
+ };
+ }
+};
+
+// src/trello/custom-field/types.ts
+var TrelloCustomFieldAriResourceOwner = "trello", TrelloCustomFieldAriResourceType = "custom-field";
+
+// src/trello/custom-field/manifest.ts
+var trelloCustomFieldAriStaticOpts = {
+ qualifier: "ari",
+ platformQualifier: "cloud",
+ cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
+ resourceOwner: TrelloCustomFieldAriResourceOwner,
+ resourceType: TrelloCustomFieldAriResourceType,
+ resourceIdSlug: "workspace/{workspaceId}/{customFieldId}",
+ resourceIdSegmentFormats: {
+ workspaceId: /[a-zA-Z0-9\-_.]*/,
+ // eslint-disable-line no-useless-escape
+ customFieldId: /[a-zA-Z0-9\-_.]*/
+ // eslint-disable-line no-useless-escape
+ }
+};
+
+// src/trello/custom-field/index.ts
+var TrelloCustomFieldAri = class _TrelloCustomFieldAri extends RegisteredAri {
+ constructor(opts) {
+ super(opts);
+ this._workspaceId = opts.resourceIdSegmentValues.workspaceId, this._customFieldId = opts.resourceIdSegmentValues.customFieldId;
+ }
+ get workspaceId() {
+ return this._workspaceId;
+ }
+ get customFieldId() {
+ return this._customFieldId;
+ }
+ static create(opts) {
+ let derivedOpts = {
+ qualifier: trelloCustomFieldAriStaticOpts.qualifier,
+ platformQualifier: trelloCustomFieldAriStaticOpts.platformQualifier,
+ cloudId: void 0,
+ resourceOwner: trelloCustomFieldAriStaticOpts.resourceOwner,
+ resourceType: trelloCustomFieldAriStaticOpts.resourceType,
+ resourceId: `workspace/${opts.workspaceId}/${opts.customFieldId}`,
+ resourceIdSegmentValues: {
+ workspaceId: opts.workspaceId || "",
+ customFieldId: opts.customFieldId || ""
+ }
+ }, ariOpts = AriParser.fromOpts(derivedOpts, trelloCustomFieldAriStaticOpts);
+ return new _TrelloCustomFieldAri(ariOpts);
+ }
+ static parse(maybeAri) {
+ let opts = AriParser.fromString(maybeAri, trelloCustomFieldAriStaticOpts);
+ return new _TrelloCustomFieldAri(opts);
+ }
+ getVariables() {
+ return {
+ workspaceId: this.workspaceId,
+ customFieldId: this.customFieldId
+ };
+ }
+};
+
+// src/trello/emoji/types.ts
+var TrelloEmojiAriResourceOwner = "trello", TrelloEmojiAriResourceType = "emoji";
+
+// src/trello/emoji/manifest.ts
+var trelloEmojiAriStaticOpts = {
+ qualifier: "ari",
+ platformQualifier: "cloud",
+ cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
+ resourceOwner: TrelloEmojiAriResourceOwner,
+ resourceType: TrelloEmojiAriResourceType,
+ resourceIdSlug: "{customEmojiId}",
+ resourceIdSegmentFormats: {
+ customEmojiId: /[a-zA-Z0-9\-_.]*/
+ // eslint-disable-line no-useless-escape
+ }
+};
+
+// src/trello/emoji/index.ts
+var TrelloEmojiAri = class _TrelloEmojiAri extends RegisteredAri {
+ constructor(opts) {
+ super(opts);
+ this._customEmojiId = opts.resourceIdSegmentValues.customEmojiId;
+ }
+ get customEmojiId() {
+ return this._customEmojiId;
+ }
+ static create(opts) {
+ let derivedOpts = {
+ qualifier: trelloEmojiAriStaticOpts.qualifier,
+ platformQualifier: trelloEmojiAriStaticOpts.platformQualifier,
+ cloudId: void 0,
+ resourceOwner: trelloEmojiAriStaticOpts.resourceOwner,
+ resourceType: trelloEmojiAriStaticOpts.resourceType,
+ resourceId: `${opts.customEmojiId}`,
+ resourceIdSegmentValues: {
+ customEmojiId: opts.customEmojiId || ""
+ }
+ }, ariOpts = AriParser.fromOpts(derivedOpts, trelloEmojiAriStaticOpts);
+ return new _TrelloEmojiAri(ariOpts);
+ }
+ static parse(maybeAri) {
+ let opts = AriParser.fromString(maybeAri, trelloEmojiAriStaticOpts);
+ return new _TrelloEmojiAri(opts);
+ }
+ getVariables() {
+ return {
+ customEmojiId: this.customEmojiId
+ };
+ }
+};
+
// src/trello/enterprise/types.ts
var TrelloEnterpriseAriResourceOwner = "trello", TrelloEnterpriseAriResourceType = "enterprise";
// src/trello/enterprise/manifest.ts
var trelloEnterpriseAriStaticOpts = {
qualifier: "ari",
platformQualifier: "cloud",
cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
resourceOwner: TrelloEnterpriseAriResourceOwner,
resourceType: TrelloEnterpriseAriResourceType,
resourceIdSlug: "{enterpriseId}",
resourceIdSegmentFormats: {
@@ -514,16 +884,76 @@
};
}
};
+// src/trello/label/types.ts
+var TrelloLabelAriResourceOwner = "trello", TrelloLabelAriResourceType = "label";
+
+// src/trello/label/manifest.ts
+var trelloLabelAriStaticOpts = {
+ qualifier: "ari",
+ platformQualifier: "cloud",
+ cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
+ resourceOwner: TrelloLabelAriResourceOwner,
+ resourceType: TrelloLabelAriResourceType,
+ resourceIdSlug: "workspace/{workspaceId}/{labelId}",
+ resourceIdSegmentFormats: {
+ workspaceId: /[a-zA-Z0-9\-_.]*/,
+ // eslint-disable-line no-useless-escape
+ labelId: /[a-zA-Z0-9\-_.]*/
+ // eslint-disable-line no-useless-escape
+ }
+};
+
+// src/trello/label/index.ts
+var TrelloLabelAri = class _TrelloLabelAri extends RegisteredAri {
+ constructor(opts) {
+ super(opts);
+ this._workspaceId = opts.resourceIdSegmentValues.workspaceId, this._labelId = opts.resourceIdSegmentValues.labelId;
+ }
+ get workspaceId() {
+ return this._workspaceId;
+ }
+ get labelId() {
+ return this._labelId;
+ }
+ static create(opts) {
+ let derivedOpts = {
+ qualifier: trelloLabelAriStaticOpts.qualifier,
+ platformQualifier: trelloLabelAriStaticOpts.platformQualifier,
+ cloudId: void 0,
+ resourceOwner: trelloLabelAriStaticOpts.resourceOwner,
+ resourceType: trelloLabelAriStaticOpts.resourceType,
+ resourceId: `workspace/${opts.workspaceId}/${opts.labelId}`,
+ resourceIdSegmentValues: {
+ workspaceId: opts.workspaceId || "",
+ labelId: opts.labelId || ""
+ }
+ }, ariOpts = AriParser.fromOpts(derivedOpts, trelloLabelAriStaticOpts);
+ return new _TrelloLabelAri(ariOpts);
+ }
+ static parse(maybeAri) {
+ let opts = AriParser.fromString(maybeAri, trelloLabelAriStaticOpts);
+ return new _TrelloLabelAri(opts);
+ }
+ getVariables() {
+ return {
+ workspaceId: this.workspaceId,
+ labelId: this.labelId
+ };
+ }
+};
+
// src/trello/list/types.ts
var TrelloListAriResourceOwner = "trello", TrelloListAriResourceType = "list";
// src/trello/list/manifest.ts
var trelloListAriStaticOpts = {
qualifier: "ari",
platformQualifier: "cloud",
cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
resourceOwner: TrelloListAriResourceOwner,
resourceType: TrelloListAriResourceType,
resourceIdSlug: "workspace/{workspaceId}/{listId}",
resourceIdSegmentFormats: {
@@ -572,16 +1002,260 @@
};
}
};
+// src/trello/logo/types.ts
+var TrelloLogoAriResourceOwner = "trello", TrelloLogoAriResourceType = "logo";
+
+// src/trello/logo/manifest.ts
+var trelloLogoAriStaticOpts = {
+ qualifier: "ari",
+ platformQualifier: "cloud",
+ cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
+ resourceOwner: TrelloLogoAriResourceOwner,
+ resourceType: TrelloLogoAriResourceType,
+ resourceIdSlug: "type-id/logo-type/{logoType}/{typeId}/{logoHash}",
+ resourceIdSegmentFormats: {
+ logoType: /(?:organization|enterprise)/,
+ // eslint-disable-line no-useless-escape
+ typeId: /[a-zA-Z0-9\-_.]*/,
+ // eslint-disable-line no-useless-escape
+ logoHash: /[a-zA-Z0-9\-_.]*/
+ // eslint-disable-line no-useless-escape
+ }
+};
+
+// src/trello/logo/index.ts
+var TrelloLogoAri = class _TrelloLogoAri extends RegisteredAri {
+ constructor(opts) {
+ super(opts);
+ this._logoType = opts.resourceIdSegmentValues.logoType, this._typeId = opts.resourceIdSegmentValues.typeId, this._logoHash = opts.resourceIdSegmentValues.logoHash;
+ }
+ get logoType() {
+ return this._logoType;
+ }
+ get typeId() {
+ return this._typeId;
+ }
+ get logoHash() {
+ return this._logoHash;
+ }
+ static create(opts) {
+ let derivedOpts = {
+ qualifier: trelloLogoAriStaticOpts.qualifier,
+ platformQualifier: trelloLogoAriStaticOpts.platformQualifier,
+ cloudId: void 0,
+ resourceOwner: trelloLogoAriStaticOpts.resourceOwner,
+ resourceType: trelloLogoAriStaticOpts.resourceType,
+ resourceId: `type-id/logo-type/${opts.logoType}/${opts.typeId}/${opts.logoHash}`,
+ resourceIdSegmentValues: {
+ logoType: opts.logoType,
+ typeId: opts.typeId || "",
+ logoHash: opts.logoHash || ""
+ }
+ }, ariOpts = AriParser.fromOpts(derivedOpts, trelloLogoAriStaticOpts);
+ return new _TrelloLogoAri(ariOpts);
+ }
+ static parse(maybeAri) {
+ let opts = AriParser.fromString(maybeAri, trelloLogoAriStaticOpts);
+ return new _TrelloLogoAri(opts);
+ }
+ getVariables() {
+ return {
+ logoType: this.logoType,
+ typeId: this.typeId,
+ logoHash: this.logoHash
+ };
+ }
+};
+
+// src/trello/planner/types.ts
+var TrelloPlannerAriResourceOwner = "trello", TrelloPlannerAriResourceType = "planner";
+
+// src/trello/planner/manifest.ts
+var trelloPlannerAriStaticOpts = {
+ qualifier: "ari",
+ platformQualifier: "cloud",
+ cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
+ resourceOwner: TrelloPlannerAriResourceOwner,
+ resourceType: TrelloPlannerAriResourceType,
+ resourceIdSlug: "workspace/{workspaceId}/{plannerId}",
+ resourceIdSegmentFormats: {
+ workspaceId: /[a-zA-Z0-9\-_.]*/,
+ // eslint-disable-line no-useless-escape
+ plannerId: /[a-zA-Z0-9\-_.]*/
+ // eslint-disable-line no-useless-escape
+ }
+};
+
+// src/trello/planner/index.ts
+var TrelloPlannerAri = class _TrelloPlannerAri extends RegisteredAri {
+ constructor(opts) {
+ super(opts);
+ this._workspaceId = opts.resourceIdSegmentValues.workspaceId, this._plannerId = opts.resourceIdSegmentValues.plannerId;
+ }
+ get workspaceId() {
+ return this._workspaceId;
+ }
+ get plannerId() {
+ return this._plannerId;
+ }
+ static create(opts) {
+ let derivedOpts = {
+ qualifier: trelloPlannerAriStaticOpts.qualifier,
+ platformQualifier: trelloPlannerAriStaticOpts.platformQualifier,
+ cloudId: void 0,
+ resourceOwner: trelloPlannerAriStaticOpts.resourceOwner,
+ resourceType: trelloPlannerAriStaticOpts.resourceType,
+ resourceId: `workspace/${opts.workspaceId}/${opts.plannerId}`,
+ resourceIdSegmentValues: {
+ workspaceId: opts.workspaceId || "",
+ plannerId: opts.plannerId || ""
+ }
+ }, ariOpts = AriParser.fromOpts(derivedOpts, trelloPlannerAriStaticOpts);
+ return new _TrelloPlannerAri(ariOpts);
+ }
+ static parse(maybeAri) {
+ let opts = AriParser.fromString(maybeAri, trelloPlannerAriStaticOpts);
+ return new _TrelloPlannerAri(opts);
+ }
+ getVariables() {
+ return {
+ workspaceId: this.workspaceId,
+ plannerId: this.plannerId
+ };
+ }
+};
+
+// src/trello/planner-calendar/types.ts
+var TrelloPlannerCalendarAriResourceOwner = "trello", TrelloPlannerCalendarAriResourceType = "planner-calendar";
+
+// src/trello/planner-calendar/manifest.ts
+var trelloPlannerCalendarAriStaticOpts = {
+ qualifier: "ari",
+ platformQualifier: "cloud",
+ cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
+ resourceOwner: TrelloPlannerCalendarAriResourceOwner,
+ resourceType: TrelloPlannerCalendarAriResourceType,
+ resourceIdSlug: "workspace/{workspaceId}/{plannerCalendarId}",
+ resourceIdSegmentFormats: {
+ workspaceId: /[a-zA-Z0-9\-_.]*/,
+ // eslint-disable-line no-useless-escape
+ plannerCalendarId: /[a-zA-Z0-9\-_.]*/
+ // eslint-disable-line no-useless-escape
+ }
+};
+
+// src/trello/planner-calendar/index.ts
+var TrelloPlannerCalendarAri = class _TrelloPlannerCalendarAri extends RegisteredAri {
+ constructor(opts) {
+ super(opts);
+ this._workspaceId = opts.resourceIdSegmentValues.workspaceId, this._plannerCalendarId = opts.resourceIdSegmentValues.plannerCalendarId;
+ }
+ get workspaceId() {
+ return this._workspaceId;
+ }
+ get plannerCalendarId() {
+ return this._plannerCalendarId;
+ }
+ static create(opts) {
+ let derivedOpts = {
+ qualifier: trelloPlannerCalendarAriStaticOpts.qualifier,
+ platformQualifier: trelloPlannerCalendarAriStaticOpts.platformQualifier,
+ cloudId: void 0,
+ resourceOwner: trelloPlannerCalendarAriStaticOpts.resourceOwner,
+ resourceType: trelloPlannerCalendarAriStaticOpts.resourceType,
+ resourceId: `workspace/${opts.workspaceId}/${opts.plannerCalendarId}`,
+ resourceIdSegmentValues: {
+ workspaceId: opts.workspaceId || "",
+ plannerCalendarId: opts.plannerCalendarId || ""
+ }
+ }, ariOpts = AriParser.fromOpts(derivedOpts, trelloPlannerCalendarAriStaticOpts);
+ return new _TrelloPlannerCalendarAri(ariOpts);
+ }
+ static parse(maybeAri) {
+ let opts = AriParser.fromString(maybeAri, trelloPlannerCalendarAriStaticOpts);
+ return new _TrelloPlannerCalendarAri(opts);
+ }
+ getVariables() {
+ return {
+ workspaceId: this.workspaceId,
+ plannerCalendarId: this.plannerCalendarId
+ };
+ }
+};
+
+// src/trello/planner-event-card/types.ts
+var TrelloPlannerEventCardAriResourceOwner = "trello", TrelloPlannerEventCardAriResourceType = "planner-event-card";
+
+// src/trello/planner-event-card/manifest.ts
+var trelloPlannerEventCardAriStaticOpts = {
+ qualifier: "ari",
+ platformQualifier: "cloud",
+ cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
+ resourceOwner: TrelloPlannerEventCardAriResourceOwner,
+ resourceType: TrelloPlannerEventCardAriResourceType,
+ resourceIdSlug: "workspace/{workspaceId}/{plannerEventCardId}",
+ resourceIdSegmentFormats: {
+ workspaceId: /[a-zA-Z0-9\-_.]*/,
+ // eslint-disable-line no-useless-escape
+ plannerEventCardId: /[a-zA-Z0-9\-_.]*/
+ // eslint-disable-line no-useless-escape
+ }
+};
+
+// src/trello/planner-event-card/index.ts
+var TrelloPlannerEventCardAri = class _TrelloPlannerEventCardAri extends RegisteredAri {
+ constructor(opts) {
+ super(opts);
+ this._workspaceId = opts.resourceIdSegmentValues.workspaceId, this._plannerEventCardId = opts.resourceIdSegmentValues.plannerEventCardId;
+ }
+ get workspaceId() {
+ return this._workspaceId;
+ }
+ get plannerEventCardId() {
+ return this._plannerEventCardId;
+ }
+ static create(opts) {
+ let derivedOpts = {
+ qualifier: trelloPlannerEventCardAriStaticOpts.qualifier,
+ platformQualifier: trelloPlannerEventCardAriStaticOpts.platformQualifier,
+ cloudId: void 0,
+ resourceOwner: trelloPlannerEventCardAriStaticOpts.resourceOwner,
+ resourceType: trelloPlannerEventCardAriStaticOpts.resourceType,
+ resourceId: `workspace/${opts.workspaceId}/${opts.plannerEventCardId}`,
+ resourceIdSegmentValues: {
+ workspaceId: opts.workspaceId || "",
+ plannerEventCardId: opts.plannerEventCardId || ""
+ }
+ }, ariOpts = AriParser.fromOpts(derivedOpts, trelloPlannerEventCardAriStaticOpts);
+ return new _TrelloPlannerEventCardAri(ariOpts);
+ }
+ static parse(maybeAri) {
+ let opts = AriParser.fromString(maybeAri, trelloPlannerEventCardAriStaticOpts);
+ return new _TrelloPlannerEventCardAri(opts);
+ }
+ getVariables() {
+ return {
+ workspaceId: this.workspaceId,
+ plannerEventCardId: this.plannerEventCardId
+ };
+ }
+};
+
// src/trello/role/types.ts
var TrelloRoleAriResourceOwner = "trello", TrelloRoleAriResourceType = "role";
// src/trello/role/manifest.ts
var trelloRoleAriStaticOpts = {
qualifier: "ari",
platformQualifier: "cloud",
cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
resourceOwner: TrelloRoleAriResourceOwner,
resourceType: TrelloRoleAriResourceType,
resourceIdSlug: "{roleGroup}/{roleType}",
resourceIdSegmentFormats: {
@@ -638,8 +1312,9 @@
var trelloSiteAriStaticOpts = {
qualifier: "ari",
platformQualifier: "cloud",
cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
resourceOwner: TrelloSiteAriResourceOwner,
resourceType: TrelloSiteAriResourceType,
resourceIdSlug: "trello",
resourceIdSegmentFormats: {}
@@ -670,16 +1345,69 @@
return {};
}
};
+// src/trello/sticker/types.ts
+var TrelloStickerAriResourceOwner = "trello", TrelloStickerAriResourceType = "sticker";
+
+// src/trello/sticker/manifest.ts
+var trelloStickerAriStaticOpts = {
+ qualifier: "ari",
+ platformQualifier: "cloud",
+ cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
+ resourceOwner: TrelloStickerAriResourceOwner,
+ resourceType: TrelloStickerAriResourceType,
+ resourceIdSlug: "{customStickerId}",
+ resourceIdSegmentFormats: {
+ customStickerId: /[a-zA-Z0-9\-_.]*/
+ // eslint-disable-line no-useless-escape
+ }
+};
+
+// src/trello/sticker/index.ts
+var TrelloStickerAri = class _TrelloStickerAri extends RegisteredAri {
+ constructor(opts) {
+ super(opts);
+ this._customStickerId = opts.resourceIdSegmentValues.customStickerId;
+ }
+ get customStickerId() {
+ return this._customStickerId;
+ }
+ static create(opts) {
+ let derivedOpts = {
+ qualifier: trelloStickerAriStaticOpts.qualifier,
+ platformQualifier: trelloStickerAriStaticOpts.platformQualifier,
+ cloudId: void 0,
+ resourceOwner: trelloStickerAriStaticOpts.resourceOwner,
+ resourceType: trelloStickerAriStaticOpts.resourceType,
+ resourceId: `${opts.customStickerId}`,
+ resourceIdSegmentValues: {
+ customStickerId: opts.customStickerId || ""
+ }
+ }, ariOpts = AriParser.fromOpts(derivedOpts, trelloStickerAriStaticOpts);
+ return new _TrelloStickerAri(ariOpts);
+ }
+ static parse(maybeAri) {
+ let opts = AriParser.fromString(maybeAri, trelloStickerAriStaticOpts);
+ return new _TrelloStickerAri(opts);
+ }
+ getVariables() {
+ return {
+ customStickerId: this.customStickerId
+ };
+ }
+};
+
// src/trello/user/types.ts
var TrelloUserAriResourceOwner = "trello", TrelloUserAriResourceType = "user";
// src/trello/user/manifest.ts
var trelloUserAriStaticOpts = {
qualifier: "ari",
platformQualifier: "cloud",
cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
resourceOwner: TrelloUserAriResourceOwner,
resourceType: TrelloUserAriResourceType,
resourceIdSlug: "{userId}",
resourceIdSegmentFormats: {
@@ -729,8 +1457,9 @@
var trelloWorkspaceAriStaticOpts = {
qualifier: "ari",
platformQualifier: "cloud",
cloudId: new RegExp("^$"),
+ // eslint-disable-line no-useless-escape
resourceOwner: TrelloWorkspaceAriResourceOwner,
resourceType: TrelloWorkspaceAriResourceType,
resourceIdSlug: "{workspaceId}",
resourceIdSegmentFormats: {
@@ -774,13 +1503,25 @@
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
TrelloAttachmentAri,
+ TrelloAvatarAri,
+ TrelloBackgroundAri,
TrelloBoardAri,
TrelloCardAri,
+ TrelloCheckItemAri,
+ TrelloChecklistAri,
+ TrelloCustomFieldAri,
+ TrelloEmojiAri,
TrelloEnterpriseAri,
+ TrelloLabelAri,
TrelloListAri,
+ TrelloLogoAri,
+ TrelloPlannerAri,
+ TrelloPlannerCalendarAri,
+ TrelloPlannerEventCardAri,
TrelloRoleAri,
TrelloSiteAri,
+ TrelloStickerAri,
TrelloUserAri,
TrelloWorkspaceAri
});