@agility/management-sdk 0.1.22 → 0.1.23

package/.cursor/manifest.md

@@ -0,0 +1,65 @@
+# Agility CMS Management SDK Test Suite Plan
+
+## Setup
+
+*   [x] Choose and install a test runner (Suggesting Jest).
+*   [x] Configure test scripts in `package.json`.
+*   [x] Set up test environment configuration (handling API keys, GUIDs etc., likely via environment variables).
+    * Using `.env` file for configuration.
+    * Implemented Azure Table Storage refresh token flow in `src/tests/authHelper.ts`.
+
+## Core Functionality Tests
+
+*   [x] Test SDK client initialization (`ApiClient` class).
+    * Tested via `src/tests/authHelper.ts` integration in `src/tests/sdk.test.ts`.
+*   [ ] Test basic read operations (e.g., getting models, locales).
+
+## CRUD Operation Tests (Integration Tests)
+
+*   **Content Items**
+    *   [ ] Get Content List
+    *   [ ] Get Content Item by ID
+    *   [ ] Create Content Item
+    *   [ ] Update Content Item
+    *   [ ] Delete Content Item
+    *   [ ] Publish Content Item
+    *   [ ] Unpublish Content Item
+    *   [ ] Request Content Approval
+*   **Content Models**
+    *   [ ] Get Models List
+    *   [ ] Get Model by ID
+    *   [ ] Save Model (Create/Update)
+    *   [ ] Delete Model
+*   **Assets**
+    *   [ ] Get Assets List
+    *   [ ] Upload Asset
+    *   [ ] Get Asset by ID
+    *   [ ] Delete Asset
+*   **Containers**
+    *   [ ] Get Containers List
+    *   [ ] Get Container by ID
+    *   [ ] Save Container (Create/Update)
+    *   [ ] Delete Container
+*   **Pages**
+    *   [ ] Get Pages List
+    *   [ ] Get Page by ID
+    *   [ ] Create Page
+    *   [ ] Update Page
+    *   [ ] Delete Page
+    *   [ ] Publish Page
+    *   [ ] Unpublish Page
+    *   [ ] Request Page Approval
+*   **Sync/Batch Operations**
+    *   [ ] Test Sync Endpoints
+    *   [ ] Test Batch Endpoints
+*   **Other Endpoints**
+    *   [ ] Test URL Redirection endpoints
+    *   [ ] Test Site Map endpoints
+    *   [ ] Test Webhook endpoints
+
+## Refinement
+
+*   [ ] Organize tests logically (e.g., by SDK module/feature).
+*   [ ] Ensure tests clean up created resources (delete items, models, etc.).
+*   [ ] Add tests for error handling scenarios.
+*   [ ] Review structure for Turborepo compatibility (e.g., tests in a `src/__tests__` or root `tests` folder).

package/.cursor/rules/agility_cms_sdk_rules.mdc

@@ -0,0 +1,155 @@
+---
+description: 
+globs: 
+alwaysApply: false
+---
+# Agility CMS Management SDK Rules Overview
+
+## Introduction
+This document serves as the central reference for all Agility CMS Management SDK rules. These rules are designed to help developers implement the SDK effectively, securely, and efficiently.
+
+## Rule Categories
+
+### 1. Core Functionality
+- [Setup and Authentication](mdc:setup_and_auth.mdc)
+  - Authentication flow
+  - Token management
+  - SDK initialization
+  - Best practices
+
+- [Content Management](mdc:content_management.mdc)
+  - Content operations
+  - Publishing workflow
+  - Content retrieval
+  - Batch operations
+
+- [Page Management](mdc:page_management.mdc)
+  - Page operations
+  - Template management
+  - Sitemap handling
+  - Publishing workflow
+
+- [Asset Management](mdc:asset_management.mdc)
+  - File uploads
+  - Folder management
+  - Asset retrieval
+  - Gallery operations
+
+- [Webhook Management](mdc:webhook_management.mdc)
+  - Webhook setup
+  - Event handling
+  - Security considerations
+  - Best practices
+
+### 2. Project Structure
+- [Configuration](mdc:configuration.mdc)
+  - Environment setup
+  - SDK initialization
+  - Error handling
+  - Logging
+
+- [Common Patterns](mdc:common_patterns.mdc)
+  - Content caching
+  - Batch operations
+  - Page hierarchy
+  - Asset optimization
+  - Webhook patterns
+
+- [Testing and Debugging](mdc:testing_and_debugging.mdc)
+  - Unit testing
+  - Integration testing
+  - Debugging tools
+  - Performance testing
+
+- [Security](mdc:security.mdc)
+  - Authentication security
+  - API security
+  - Data security
+  - Webhook security
+
+## Getting Started
+
+### Quick Start
+1. Set up your environment variables (see [Configuration](mdc:configuration.mdc))
+2. Initialize the SDK (see [Setup and Authentication](mdc:setup_and_auth.mdc))
+3. Start implementing your features using the appropriate rule files
+
+### Best Practices
+1. Always follow security guidelines (see [Security](mdc:security.mdc))
+2. Implement proper error handling (see [Configuration](mdc:configuration.mdc))
+3. Use common patterns for efficiency (see [Common Patterns](mdc:common_patterns.mdc))
+4. Write comprehensive tests (see [Testing and Debugging](mdc:testing_and_debugging.mdc))
+
+## Implementation Guide
+
+### Content Management
+```typescript
+// See content_management.mdc for details
+const content = await apiClient.contentMethods.getContentItem(contentID, guid, locale);
+```
+
+### Page Management
+```typescript
+// See page_management.mdc for details
+const page = await apiClient.pageMethods.getPage(pageID, guid, locale);
+```
+
+### Asset Management
+```typescript
+// See asset_management.mdc for details
+await apiClient.assetMethods.upload(formData, path, guid, groupingID);
+```
+
+### Webhook Setup
+```typescript
+// See webhook_management.mdc for details
+const webhook = await apiClient.webhookMethods.saveWebhook(guid, webhookConfig);
+```
+
+## Common Scenarios
+
+### 1. Content Publishing Workflow
+1. Create content (see [Content Management](mdc:content_management.mdc))
+2. Request approval
+3. Publish content
+4. Monitor status
+
+### 2. Page Management
+1. Create page template (see [Page Management](mdc:page_management.mdc))
+2. Create page
+3. Add content
+4. Publish page
+
+### 3. Asset Management
+1. Create folder structure (see [Asset Management](mdc:asset_management.mdc))
+2. Upload assets
+3. Organize in galleries
+4. Link to content
+
+### 4. Webhook Implementation
+1. Set up webhook (see [Webhook Management](mdc:webhook_management.mdc))
+2. Implement handlers
+3. Test integration
+4. Monitor events
+
+## Troubleshooting
+- Check [Testing and Debugging](mdc:testing_and_debugging.mdc) for debugging tools
+- Review [Common Patterns](mdc:common_patterns.mdc) for known issues
+- Consult [Security](mdc:security.mdc) for security-related issues
+
+## Additional Resources
+- [Agility CMS Documentation](mdc:https:/help.agilitycms.com/hc/en-us)
+- [TypeScript Documentation](mdc:https:/www.typescriptlang.org/docs)
+- [Community Forums](mdc:https:/help.agilitycms.com/hc/en-us/community/topics)
+
+## Contributing
+If you have additional rules or improvements to suggest:
+1. Create a new rule file
+2. Update this central reference
+3. Submit a pull request
+
+## Version History
+- v1.0.0: Initial release
+- v1.1.0: Added security rules
+- v1.2.0: Added common patterns
+- v1.3.0: Added testing and debugging rules

package/.cursor/rules/asset_management.mdc

@@ -0,0 +1,97 @@
+---
+description: 
+globs: 
+alwaysApply: false
+---
+# Agility CMS Asset Management Rules
+
+## Asset Operations
+- Always provide required parameters: guid, mediaID
+- Use appropriate methods for different asset operations
+- Handle file uploads and management properly
+
+## File Upload
+1. Upload single file:
+   ```typescript
+   const form = new FormData();
+   form.append('files', file, fileName);
+   await apiClient.assetMethods.upload(form, agilityFolderPath, guid, groupingID);
+   ```
+
+2. Upload multiple files:
+   ```typescript
+   const form = new FormData();
+   files.forEach(file => {
+     form.append('files', file, file.name);
+   });
+   await apiClient.assetMethods.upload(form, agilityFolderPath, guid, groupingID);
+   ```
+
+## Folder Management
+1. Create folder:
+   ```typescript
+   await apiClient.assetMethods.createFolder(originKey, guid);
+   ```
+
+2. Delete folder:
+   ```typescript
+   await apiClient.assetMethods.deleteFolder(originKey, guid, mediaID);
+   ```
+
+3. Rename folder:
+   ```typescript
+   await apiClient.assetMethods.renameFolder(folderName, newFolderName, guid, mediaID);
+   ```
+
+## File Operations
+1. Delete file:
+   ```typescript
+   await apiClient.assetMethods.deleteFile(mediaID, guid);
+   ```
+
+2. Move file:
+   ```typescript
+   await apiClient.assetMethods.moveFile(mediaID, newFolder, guid);
+   ```
+
+## Asset Retrieval
+1. Get media list:
+   ```typescript
+   const mediaList = await apiClient.assetMethods.getMediaList(pageSize, recordOffset, guid);
+   ```
+
+2. Get asset by ID:
+   ```typescript
+   const asset = await apiClient.assetMethods.getAssetByID(mediaID, guid);
+   ```
+
+3. Get asset by URL:
+   ```typescript
+   const asset = await apiClient.assetMethods.getAssetByUrl(url, guid);
+   ```
+
+## Gallery Management
+1. Get gallery by ID:
+   ```typescript
+   const gallery = await apiClient.assetMethods.getGalleryById(guid, id);
+   ```
+
+2. Get gallery by name:
+   ```typescript
+   const gallery = await apiClient.assetMethods.getGalleryByName(guid, galleryName);
+   ```
+
+3. Save gallery:
+   ```typescript
+   await apiClient.assetMethods.saveGallery(guid, gallery);
+   ```
+
+## Best Practices
+- Validate file types before upload
+- Implement proper error handling
+- Use appropriate folder structure
+- Optimize file sizes before upload
+- Use descriptive file names
+- Implement proper access control
+- Monitor storage usage
+- Use appropriate file formats

package/.cursor/rules/common_patterns.mdc

@@ -0,0 +1,5 @@
+---
+description:
+globs:
+alwaysApply: false
+---

package/.cursor/rules/configuration.mdc

@@ -0,0 +1,5 @@
+---
+description:
+globs:
+alwaysApply: false
+---

package/.cursor/rules/content_management.mdc

@@ -0,0 +1,5 @@
+---
+description:
+globs:
+alwaysApply: false
+---

package/.cursor/rules/page_management.mdc

@@ -0,0 +1,5 @@
+---
+description:
+globs:
+alwaysApply: false
+---

package/.cursor/rules/security.mdc

@@ -0,0 +1,5 @@
+---
+description:
+globs:
+alwaysApply: false
+---

package/.cursor/rules/setup_and_auth.mdc

@@ -0,0 +1,5 @@
+---
+description:
+globs:
+alwaysApply: false
+---

package/.cursor/rules/testing_and_debugging.mdc

@@ -0,0 +1,5 @@
+---
+description:
+globs:
+alwaysApply: false
+---

package/.cursor/rules/webhook_management.mdc

@@ -0,0 +1,61 @@
+---
+description: 
+globs: 
+alwaysApply: false
+---
+# Agility CMS Webhook Management Rules
+
+## Webhook Operations
+- Always provide required parameters: guid, webhookID
+- Use appropriate methods for different webhook operations
+- Handle webhook events properly
+
+## Webhook Management
+1. List webhooks:
+   ```typescript
+   const webhooks = await apiClient.webhookMethods.webhookList(guid, take, skip);
+   ```
+
+2. Create webhook:
+   ```typescript
+   const webhook = new Webhook();
+   // Set required properties
+   await apiClient.webhookMethods.saveWebhook(guid, webhook);
+   ```
+
+3. Get webhook:
+   ```typescript
+   const webhook = await apiClient.webhookMethods.getWebhook(guid, webhookID);
+   ```
+
+4. Delete webhook:
+   ```typescript
+   await apiClient.webhookMethods.deleteWebhook(guid, webhookID);
+   ```
+
+## Webhook Configuration
+1. Required properties:
+   - URL endpoint
+   - Event types to listen for
+   - Authentication if required
+   - Retry policy
+   - Payload format
+
+2. Event types:
+   - Content changes
+   - Page changes
+   - Asset changes
+   - User changes
+   - System events
+
+## Best Practices
+- Implement proper error handling
+- Use HTTPS endpoints
+- Validate webhook payloads
+- Implement retry logic
+- Monitor webhook delivery
+- Secure webhook endpoints
+- Log webhook events
+- Handle rate limiting
+- Use appropriate authentication
+- Test webhook endpoints

package/.env

@@ -0,0 +1,11 @@
+AGILITY_GUID=f3866b86-u
+AGILITY_API_KEY=defaultpreview.2672a9e1f5f8fade023029763b540c64eabfab48f92e693fa01081d845783dca
+AGILITY_LOCALES=en-us
+AGILITY_SITEMAP=website
+AGILITY_API_ISPREVIEW=true
+
+AGILITY_MANAGEMENT_API_BASE_URL=https://mgmt.aglty.io
+TEST_ENV=dev
+STORAGE_ACCOUNT=agilitydevstorage
+STORAGE_ACCOUNT_KEY=0gMvadhiKgr04J0u0dlui8gaH6rY8kRo46vNvG/JmGAmzhMqsQ7V+bonmZOVgqMOo9STt0xyEToHBpJFjVeR/w==
+STORAGE_ACCOUNT_TABLE=TokenInfo

package/README.md

@@ -12,8 +12,82 @@
 ### Prerequisites
 1. Clone the repository agility-cms-management-sdk-typescript.
 2. Import the index file to make use of the Options class.
-3. Create an object of the Options class to provide values of -
-	- token -> Bearer token to authenticate a Rest Request to perform an operation.
+3. You will need valid Agility CMS credentials to authenticate and obtain an access token.
+
+### Authentication
+Before using the SDK, you must authenticate against the Agility Management API to obtain a valid access token. This token is required for all subsequent API requests.
+
+The authentication process uses OAuth 2.0 and requires multiple steps:
+
+1. First, initiate the authorization flow by making a GET request to the authorization endpoint:
+```javascript
+const authUrl = 'https://mgmt.aglty.io/oauth/authorize';
+const params = new URLSearchParams({
+  response_type: 'code',
+  redirect_uri: 'YOUR_REDIRECT_URI',
+  state: 'YOUR_STATE',
+  scope: 'openid profile email offline_access'
+});
+
+// Redirect the user to the authorization URL
+window.location.href = `${authUrl}?${params.toString()}`;
+```
+
+2. After successful authentication, you'll receive an authorization code at your redirect URI. Use this code to obtain an access token:
+```javascript
+const response = await fetch('https://mgmt.aglty.io/oauth/token', {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/x-www-form-urlencoded'
+  },
+  body: new URLSearchParams({
+    code: 'YOUR_AUTHORIZATION_CODE'
+  })
+});
+
+const { access_token, refresh_token, expires_in } = await response.json();
+```
+
+3. Use the obtained token to initialize the SDK:
+```javascript
+import * as mgmtApi from "./index";
+
+// Initialize the Options Class with your authentication token
+let options = new mgmtApi.Options();
+options.token = access_token; // Use the token obtained from authentication
+
+// Initialize the APIClient Class
+let apiClient = new mgmtApi.ApiClient(options);
+
+let guid = "<<Provide the Guid of the Website>>";
+let locale = "<<Provide the locale of the Website>>"; // Example: en-us
+
+// Now you can make authenticated requests
+var contentItem = await apiClient.contentMethods.getContentItem(22, guid, locale);
+console.log(JSON.stringify(contentItem));
+```
+
+4. When the access token expires, use the refresh token to obtain a new access token:
+```javascript
+const response = await fetch('https://mgmt.aglty.io/oauth/refresh', {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json'
+  },
+  body: JSON.stringify({
+    refresh_token: 'YOUR_REFRESH_TOKEN'
+  })
+});
+
+const { access_token, refresh_token, expires_in } = await response.json();
+```
+
+Note: 
+- The access token has a limited lifetime (typically 1 hour)
+- The refresh token can be used to obtain new access tokens
+- Store refresh tokens securely and never expose them in client-side code
+- Implement proper error handling for authentication failures
+
 4. Create an object of Method class(es), which can be used to create and perform operations. Following is the description of Classes and their respective methods -
 
 ### Making a Request
@@ -662,6 +736,14 @@ Returns: An object with the requested Webhook.
 | `guid` | `string` | Current website guid.|
 | `webhookID` | `string` | The webhookID of the requested webhook.|
 
+## Class Instance
+
+### getLocales
+| Parameter | Type     | Description                |
+| :-------- | :------- | :------------------------- |
+| `guid` | `string` | Current website guid.|
+
+Returns: An array of locales. ex. ['en-us','fr-ca']
 
 ## Running the SDK Locally
 

package/dist/apiMethods/containerMethods.d.ts

@@ -12,6 +12,6 @@ export declare class ContainerMethods {
     getContainerSecurity(id: number, guid: string): Promise<Container>;
     getContainerList(guid: string): Promise<Container[]>;
     getNotificationList(id: number, guid: string): Promise<Notification[]>;
-    saveContainer(container: Container, guid: string): Promise<Container>;
+    saveContainer(container: Container, guid: string, forceReferenceName?: boolean): Promise<Container>;
     deleteContainer(id: number, guid: string): Promise<string>;
 }

package/dist/apiMethods/containerMethods.js

@@ -164,14 +164,15 @@ var ContainerMethods = /** @class */ (function () {
             });
         });
     };
-    ContainerMethods.prototype.saveContainer = function (container, guid) {
-        return __awaiter(this, void 0, void 0, function () {
+    ContainerMethods.prototype.saveContainer = function (container_1, guid_1) {
+        return __awaiter(this, arguments, void 0, function (container, guid, forceReferenceName) {
             var apiPath, resp, err_7;
+            if (forceReferenceName === void 0) { forceReferenceName = false; }
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         _a.trys.push([0, 2, , 3]);
-                        apiPath = "container";
+                        apiPath = "container".concat(forceReferenceName ? '?forceReferenceName=true' : '');
                         return [4 /*yield*/, this._clientInstance.executePost(apiPath, guid, this._options.token, container)];
                     case 1:
                         resp = _a.sent();

package/dist/apiMethods/contentMethods.d.ts

@@ -18,8 +18,8 @@ export declare class ContentMethods {
     approveContent(contentID: number, guid: string, locale: string, comments?: string): Promise<number[]>;
     declineContent(contentID: number, guid: string, locale: string, comments?: string): Promise<number[]>;
     deleteContent(contentID: number, guid: string, locale: string, comments?: string): Promise<number[]>;
-    saveContentItem(contentItem: ContentItem, guid: string, locale: string): Promise<number[]>;
-    saveContentItems(contentItems: ContentItem[], guid: string, locale: string): Promise<number[]>;
+    saveContentItem(contentItem: ContentItem, guid: string, locale: string): Promise<import("..").Batch | number[]>;
+    saveContentItems(contentItems: ContentItem[], guid: string, locale: string): Promise<import("..").Batch | number[]>;
     getContentItems(referenceName: string, guid: string, locale: string, listParams: ListParams): Promise<ContentList>;
     getContentList(referenceName: string, guid: string, locale: string, listParams: ListParams, filterObject?: ContentListFilterModel): Promise<ContentList>;
     getContentHistory(locale: string, guid: string, contentID: number, take?: number, skip?: number): Promise<ContentItemHistory>;

package/dist/apiMethods/contentMethods.js

@@ -285,6 +285,10 @@ var ContentMethods = /** @class */ (function () {
                             }); }); })];
                     case 2:
                         batch = _a.sent();
+                        // Aaaron May 1 2025 - if the batch has error data, return the batch not just the -1 contentID
+                        if (batch.errorData) {
+                            return [2 /*return*/, batch];
+                        }
                         contentIDs_7 = [];
                         batch.items.forEach(function (element) { return contentIDs_7.push(element.itemID); });
                         return [2 /*return*/, contentIDs_7];
@@ -317,6 +321,10 @@ var ContentMethods = /** @class */ (function () {
                             }); }); })];
                     case 2:
                         batch = _a.sent();
+                        // Aaaron May 1 2025 - if the batch has error data, return the batch not just the -1 contentID
+                        if (batch.errorData) {
+                            return [2 /*return*/, batch];
+                        }
                         contentIDs_8 = [];
                         batch.items.forEach(function (element) { return contentIDs_8.push(element.itemID); });
                         return [2 /*return*/, contentIDs_8];

package/dist/apiMethods/pageMethods.d.ts

@@ -26,7 +26,7 @@ export declare class PageMethods {
     approvePage(pageID: number, guid: string, locale: string, comments?: string): Promise<number[]>;
     declinePage(pageID: number, guid: string, locale: string, comments?: string): Promise<number[]>;
     deletePage(pageID: number, guid: string, locale: string, comments?: string): Promise<number[]>;
-    savePage(pageItem: PageItem, guid: string, locale: string, parentPageID?: number, placeBeforePageItemID?: number): Promise<number[]>;
+    savePage(pageItem: PageItem, guid: string, locale: string, parentPageID?: number, placeBeforePageItemID?: number): Promise<import("..").Batch | number[]>;
     getPageHistory(locale: string, guid: string, pageID: number, take?: number, skip?: number): Promise<PageHistory>;
     getPageComments(locale: string, guid: string, pageID: number, take?: number, skip?: number): Promise<ItemComments>;
 }

package/dist/apiMethods/pageMethods.js

@@ -430,6 +430,10 @@ var PageMethods = /** @class */ (function () {
                             }); }); })];
                     case 2:
                         batch = _a.sent();
+                        // Aaaron May 1 2025 - if the batch has error data, return the batch not just the -1 pageID
+                        if (batch.errorData) {
+                            return [2 /*return*/, batch];
+                        }
                         pageIDs_7 = [];
                         batch.items.forEach(function (element) { return pageIDs_7.push(element.itemID); });
                         return [2 /*return*/, pageIDs_7];

package/dist/models/tokenResponseData.d.ts

@@ -0,0 +1,11 @@
+export declare class TokenResponseData {
+    partitionKey: string;
+    rowKey: string;
+    access_token: string;
+    refresh_token: string;
+    token_type?: string;
+    expires_in?: number;
+    timestamp?: Date;
+    etag?: string;
+    constructor(partitionKey: string, rowKey: string);
+}

package/dist/models/tokenResponseData.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenResponseData = void 0;
+var TokenResponseData = /** @class */ (function () {
+    function TokenResponseData(partitionKey, rowKey) {
+        this.access_token = '';
+        this.refresh_token = '';
+        this.partitionKey = partitionKey;
+        this.rowKey = rowKey;
+    }
+    return TokenResponseData;
+}());
+exports.TokenResponseData = TokenResponseData;

package/dist/tests/instance.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/instance.test.js

@@ -0,0 +1,99 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var authHelper_1 = require("./authHelper"); // Import the new helper
+describe('Instance Methods', function () {
+    var apiClient;
+    var guid;
+    // Use jest.setTimeout for potentially longer async setup
+    jest.setTimeout(30000); // 30 seconds timeout for auth
+    beforeAll(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var authResult, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    console.log("Setting up Instance Methods tests...");
+                    return [4 /*yield*/, (0, authHelper_1.getApiClientWithAuth)()];
+                case 1:
+                    authResult = _a.sent();
+                    apiClient = authResult.apiClient;
+                    guid = authResult.guid; // Get guid from the helper result
+                    if (!apiClient || !guid) {
+                        throw new Error("Failed to initialize authenticated API client for tests.");
+                    }
+                    console.log("Authenticated client ready for Instance Methods tests.");
+                    return [3 /*break*/, 3];
+                case 2:
+                    error_1 = _a.sent();
+                    console.error("FATAL: Error during test setup (beforeAll):", error_1);
+                    // Rethrow or process.exit to prevent tests running without auth
+                    throw error_1;
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should get locales for the instance', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var locales, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    expect(apiClient.instanceMethods).toBeDefined();
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, apiClient.instanceMethods.getLocales(guid)];
+                case 2:
+                    locales = _a.sent();
+                    expect(locales).toBeDefined();
+                    expect(Array.isArray(locales)).toBe(true);
+                    expect(locales.length).toBeGreaterThan(0);
+                    // Check the type of the first locale code
+                    expect(typeof locales[0]).toBe('string');
+                    console.log("Found ".concat(locales.length, " locales. First locale code: ").concat(locales[0]));
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_2 = _a.sent();
+                    console.error("Error fetching locales:", error_2);
+                    throw error_2; // Re-throw to fail the test
+                case 4: return [2 /*return*/];
+            }
+        });
+    }); });
+    // Add more tests for other instanceMethods here
+});

package/dist/tests/sdk.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/sdk.test.js

@@ -0,0 +1,78 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var authHelper_1 = require("./authHelper");
+var apiClient_1 = require("../apiClient");
+describe('Authentication Helper', function () {
+    // Increase timeout for auth process
+    jest.setTimeout(30000);
+    it('should get an authenticated API client without errors', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, apiClient, guid, error_1;
+        var _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _c.trys.push([0, 2, , 3]);
+                    console.log("Testing getApiClientWithAuth...");
+                    return [4 /*yield*/, (0, authHelper_1.getApiClientWithAuth)()];
+                case 1:
+                    _a = _c.sent(), apiClient = _a.apiClient, guid = _a.guid;
+                    expect(apiClient).toBeDefined();
+                    expect(apiClient).toBeInstanceOf(apiClient_1.ApiClient);
+                    expect(guid).toBeDefined();
+                    expect(typeof guid).toBe('string');
+                    expect(guid.length).toBeGreaterThan(0);
+                    // Check that the client has options and a token/baseUrl from the auth helper
+                    expect(apiClient._options).toBeDefined();
+                    expect(apiClient._options.token).toBeDefined();
+                    expect(apiClient._options.token.length).toBeGreaterThan(0);
+                    expect(apiClient._options.baseUrl).toBeDefined();
+                    expect((_b = apiClient._options.baseUrl) === null || _b === void 0 ? void 0 : _b.startsWith('http')).toBe(true);
+                    console.log("Successfully obtained authenticated client via helper for GUID: ".concat(guid));
+                    console.log("Token starts with: ".concat(apiClient._options.token.substring(0, 10), "..."));
+                    console.log("Base URL: ".concat(apiClient._options.baseUrl));
+                    return [3 /*break*/, 3];
+                case 2:
+                    error_1 = _c.sent();
+                    console.error("Error testing getApiClientWithAuth:", error_1);
+                    throw error_1; // Fail the test if auth helper fails
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); });
+});

package/environment.example

@@ -0,0 +1,12 @@
+# Agility CMS Test Environment Variables
+# Copy this file to .env and fill in your actual values.
+
+# Required for API calls
+AGILITY_GUID=
+
+# Required for Authentication via Azure Table Storage Refresh Token Flow
+STORAGE_ACCOUNT=
+STORAGE_ACCOUNT_KEY=
+STORAGE_ACCOUNT_TABLE=
+AGILITY_MANAGEMENT_API_BASE_URL= # e.g., https://mgmt.aglty.io or https://mgmt-dev.aglty.io
+TEST_ENV=prod # Optional: set to 'dev' if using dev refresh token rowKey, otherwise defaults to 'prod' rowKey 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agility/management-sdk",
-  "version": "0.1.22",
+  "version": "0.1.23",
   "description": "Agility CMS Tyescript SDK for Management API.",
   "repository": {
     "type": "git",