@agility/management-sdk 0.1.3 → 0.1.4-beta.1

package/dist/apiMethods/authMethods.js

@@ -0,0 +1,604 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 });
+exports.TokenManager = exports.AuthMethods = void 0;
+var clientInstance_1 = require("./clientInstance");
+var exception_1 = require("../models/exception");
+var tokenStorage_1 = require("../tokenStorage");
+/**
+ * Internal authentication methods - not exposed publicly
+ * Handles OAuth flow and token management with secure storage
+ */
+var AuthMethods = /** @class */ (function () {
+    function AuthMethods(options) {
+        this._options = options;
+        this._clientInstance = new clientInstance_1.ClientInstance(this._options);
+        this._tokenStorage = new tokenStorage_1.TokenStorage();
+    }
+    /**
+     * Generate OAuth authorization URL for user authentication
+     * @param options - Authorization URL configuration options
+     * @returns Complete authorization URL for user redirection
+     *
+     * @example
+     * ```typescript
+     * const client = new ApiClient();
+     * const authUrl = client.authMethods.generateAuthUrl({
+     *     redirectUri: 'https://yourapp.com/auth/callback',
+     *     scope: 'openid profile email offline_access',
+     *     state: 'random-state-string'
+     * });
+     *
+     * // Redirect user to authorization URL
+     * window.location.href = authUrl;
+     * ```
+     */
+    AuthMethods.prototype.generateAuthUrl = function (options) {
+        var baseUrl = this._clientInstance.determineOAuthBaseUrl(options.region);
+        var authUrl = "".concat(baseUrl, "/oauth/authorize");
+        var params = new URLSearchParams({
+            response_type: options.responseType || 'code',
+            redirect_uri: options.redirectUri,
+            scope: options.scope || 'openid profile email offline_access'
+        });
+        if (options.state) {
+            params.append('state', options.state);
+        }
+        return "".concat(authUrl, "?").concat(params.toString());
+    };
+    /**
+     * Exchange authorization code for access tokens
+     * Automatically stores tokens securely and sets them in Options
+     * @param request - Token exchange request parameters
+     * @returns Promise containing access and refresh tokens
+     */
+    AuthMethods.prototype.exchangeCodeForToken = function (request, region) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data, resp, tokenResponse, tokenData, err_1, errorData;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 3, , 4]);
+                        data = new URLSearchParams({
+                            grant_type: request.grantType || 'authorization_code',
+                            code: request.code,
+                            redirect_uri: request.redirectUri
+                        });
+                        return [4 /*yield*/, this._clientInstance.executeOAuthPost('token', data, region)];
+                    case 1:
+                        resp = _b.sent();
+                        tokenResponse = resp.data;
+                        tokenData = {
+                            accessToken: tokenResponse.access_token,
+                            refreshToken: tokenResponse.refresh_token,
+                            expiresAt: tokenResponse.expires_in ? Date.now() + (tokenResponse.expires_in * 1000) : undefined,
+                            tokenType: tokenResponse.token_type,
+                            scope: tokenResponse.scope
+                        };
+                        return [4 /*yield*/, this._tokenStorage.setTokens(tokenData)];
+                    case 2:
+                        _b.sent();
+                        // Set token in shared options for immediate use
+                        this._options.token = tokenResponse.access_token;
+                        return [2 /*return*/, tokenResponse];
+                    case 3:
+                        err_1 = _b.sent();
+                        if ((_a = err_1.response) === null || _a === void 0 ? void 0 : _a.data) {
+                            errorData = err_1.response.data;
+                            throw new exception_1.Exception("OAuth token exchange failed: ".concat(errorData.error, " - ").concat(errorData.error_description || 'Unknown error'), err_1);
+                        }
+                        throw new exception_1.Exception('Unable to exchange authorization code for token', err_1);
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Refresh an expired access token using refresh token
+     * Automatically updates stored tokens and Options
+     * @param request - Token refresh request parameters
+     * @returns Promise containing new access token
+     */
+    AuthMethods.prototype.refreshAccessToken = function (request, region) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data, resp, tokenResponse, existingTokenData, tokenData, err_2, errorData;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 4, , 5]);
+                        data = new URLSearchParams({
+                            grant_type: request.grantType || 'refresh_token',
+                            refresh_token: request.refreshToken
+                        });
+                        return [4 /*yield*/, this._clientInstance.executeOAuthPost('refresh', data, region)];
+                    case 1:
+                        resp = _b.sent();
+                        tokenResponse = resp.data;
+                        return [4 /*yield*/, this._tokenStorage.getTokens()];
+                    case 2:
+                        existingTokenData = _b.sent();
+                        tokenData = {
+                            accessToken: tokenResponse.access_token,
+                            refreshToken: tokenResponse.refresh_token || (existingTokenData === null || existingTokenData === void 0 ? void 0 : existingTokenData.refreshToken),
+                            expiresAt: tokenResponse.expires_in ? Date.now() + (tokenResponse.expires_in * 1000) : undefined,
+                            tokenType: tokenResponse.token_type,
+                            scope: tokenResponse.scope
+                        };
+                        return [4 /*yield*/, this._tokenStorage.setTokens(tokenData)];
+                    case 3:
+                        _b.sent();
+                        // Update shared options with new token
+                        this._options.token = tokenResponse.access_token;
+                        return [2 /*return*/, tokenResponse];
+                    case 4:
+                        err_2 = _b.sent();
+                        if ((_a = err_2.response) === null || _a === void 0 ? void 0 : _a.data) {
+                            errorData = err_2.response.data;
+                            throw new exception_1.Exception("OAuth token refresh failed: ".concat(errorData.error, " - ").concat(errorData.error_description || 'Unknown error'), err_2);
+                        }
+                        throw new exception_1.Exception('Unable to refresh access token', err_2);
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Validate an access token and get token information
+     * @param token - Access token to validate
+     * @returns Promise containing token validation information
+     *
+     * @example
+     * ```typescript
+     * const client = new ApiClient();
+     *
+     * const tokenInfo = await client.authMethods.validateToken('your_access_token');
+     *
+     * if (tokenInfo.active) {
+     *     console.log('Token is valid');
+     *     console.log('Expires at:', new Date(tokenInfo.exp * 1000));
+     *     console.log('Scope:', tokenInfo.scope);
+     * } else {
+     *     console.log('Token is invalid or expired');
+     * }
+     * ```
+     */
+    AuthMethods.prototype.validateToken = function (token, region) {
+        return __awaiter(this, void 0, void 0, function () {
+            var resp, err_3;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this._clientInstance.executeOAuthGet('introspect', region, token)];
+                    case 1:
+                        resp = _b.sent();
+                        return [2 /*return*/, resp.data];
+                    case 2:
+                        err_3 = _b.sent();
+                        if (((_a = err_3.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
+                            return [2 /*return*/, { active: false }];
+                        }
+                        throw new exception_1.Exception('Unable to validate token', err_3);
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Revoke an access token or refresh token
+     * @param token - Token to revoke
+     * @returns Promise indicating success
+     *
+     * @example
+     * ```typescript
+     * const client = new ApiClient();
+     *
+     * // Revoke access token on logout
+     * await client.authMethods.revokeToken('access_token');
+     *
+     * // Clear the client's token
+     * client.clearToken();
+     * ```
+     */
+    AuthMethods.prototype.revokeToken = function (token, region) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data, err_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        data = new URLSearchParams({
+                            token: token
+                        });
+                        return [4 /*yield*/, this._clientInstance.executeOAuthPost('revoke', data, region)];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        err_4 = _a.sent();
+                        throw new exception_1.Exception('Unable to revoke token', err_4);
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Set the access token in the shared Options instance
+     * Also stores token in keytar for consistency
+     * @param token - Valid access token
+     */
+    AuthMethods.prototype.setAccessToken = function (token) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tokenData;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._options.token = token;
+                        tokenData = {
+                            accessToken: token,
+                            refreshToken: undefined, // No refresh token for manual tokens
+                            expiresAt: undefined, // No expiration for manual tokens
+                            tokenType: 'Bearer',
+                            scope: undefined
+                        };
+                        return [4 /*yield*/, this._tokenStorage.setTokens(tokenData)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get a valid access token - automatically refreshes if expired
+     * @returns Promise containing valid access token or null if authentication required
+     */
+    AuthMethods.prototype.getValidAccessToken = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var storedTokens, isExpired, newTokens, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // Check if manual token is set (highest priority)
+                        if (this._options.token) {
+                            return [2 /*return*/, this._options.token];
+                        }
+                        return [4 /*yield*/, this._tokenStorage.getTokens()];
+                    case 1:
+                        storedTokens = _a.sent();
+                        if (!storedTokens) {
+                            return [2 /*return*/, null];
+                        }
+                        return [4 /*yield*/, this._tokenStorage.areTokensExpired()];
+                    case 2:
+                        isExpired = _a.sent();
+                        if (!isExpired) {
+                            this._options.token = storedTokens.accessToken;
+                            return [2 /*return*/, storedTokens.accessToken];
+                        }
+                        if (!storedTokens.refreshToken) return [3 /*break*/, 7];
+                        _a.label = 3;
+                    case 3:
+                        _a.trys.push([3, 5, , 7]);
+                        return [4 /*yield*/, this.refreshAccessToken({
+                                refreshToken: storedTokens.refreshToken
+                            })];
+                    case 4:
+                        newTokens = _a.sent();
+                        return [2 /*return*/, newTokens.access_token];
+                    case 5:
+                        error_1 = _a.sent();
+                        // Refresh failed, clear invalid tokens
+                        return [4 /*yield*/, this._tokenStorage.clearTokens()];
+                    case 6:
+                        // Refresh failed, clear invalid tokens
+                        _a.sent();
+                        return [2 /*return*/, null];
+                    case 7: 
+                    // No refresh token available
+                    return [2 /*return*/, null];
+                }
+            });
+        });
+    };
+    /**
+     * Perform OAuth authentication flow
+     * @param options - OAuth configuration options
+     * @returns Promise resolving when authentication is complete
+     */
+    AuthMethods.prototype.performOAuthFlow = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var authUrl;
+            return __generator(this, function (_a) {
+                authUrl = this.generateAuthUrl(options);
+                throw new exception_1.Exception("OAuth flow not fully implemented. Please visit: ".concat(authUrl));
+            });
+        });
+    };
+    /**
+     * Clear all authentication data
+     */
+    AuthMethods.prototype.clearAuthentication = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._tokenStorage.clearTokens()];
+                    case 1:
+                        _a.sent();
+                        this._options.token = undefined;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Check if user is authenticated (has valid token)
+     * @returns Promise resolving to true if authenticated
+     */
+    AuthMethods.prototype.isAuthenticated = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var validToken;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getValidAccessToken()];
+                    case 1:
+                        validToken = _a.sent();
+                        return [2 /*return*/, validToken !== null];
+                }
+            });
+        });
+    };
+    /**
+     * Check if a token is expired based on expiration timestamp
+     * @param expiresAt - Token expiration timestamp (seconds since epoch)
+     * @param bufferSeconds - Buffer time in seconds to consider token expired early (default: 300 = 5 minutes)
+     * @returns True if token is expired or will expire within buffer time
+     *
+     * @example
+     * ```typescript
+     * const client = new ApiClient();
+     *
+     * const expiresAt = Math.floor(Date.now() / 1000) + 3600; // 1 hour from now
+     *
+     * if (client.authMethods.isTokenExpired(expiresAt)) {
+     *     console.log('Token is expired or will expire soon');
+     *     // Refresh token or re-authenticate
+     * }
+     * ```
+     */
+    AuthMethods.prototype.isTokenExpired = function (expiresAt, bufferSeconds) {
+        if (bufferSeconds === void 0) { bufferSeconds = 300; }
+        var currentTime = Math.floor(Date.now() / 1000);
+        return currentTime >= (expiresAt - bufferSeconds);
+    };
+    /**
+     * Calculate token expiration timestamp from expires_in value
+     * @param expiresIn - Token lifetime in seconds
+     * @returns Expiration timestamp (seconds since epoch)
+     *
+     * @example
+     * ```typescript
+     * const client = new ApiClient();
+     *
+     * const tokens = await client.authMethods.exchangeCodeForToken(request);
+     * const expiresAt = client.authMethods.calculateExpirationTime(tokens.expires_in);
+     *
+     * // Store expiration time for later use
+     * localStorage.setItem('token_expires_at', expiresAt.toString());
+     * ```
+     */
+    AuthMethods.prototype.calculateExpirationTime = function (expiresIn) {
+        return Math.floor(Date.now() / 1000) + expiresIn;
+    };
+    /**
+     * Generate a cryptographically secure random state parameter for OAuth
+     * @param length - Length of the state string (default: 32)
+     * @returns Random state string
+     *
+     * @example
+     * ```typescript
+     * const client = new ApiClient();
+     *
+     * const state = client.authMethods.generateState();
+     *
+     * // Store state for validation
+     * sessionStorage.setItem('oauth_state', state);
+     *
+     * // Use in authorization URL
+     * const authUrl = client.authMethods.generateAuthUrl({
+     *     redirectUri: 'https://yourapp.com/callback',
+     *     state: state
+     * });
+     * ```
+     */
+    AuthMethods.prototype.generateState = function (length) {
+        if (length === void 0) { length = 32; }
+        var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        var result = '';
+        for (var i = 0; i < length; i++) {
+            result += chars.charAt(Math.floor(Math.random() * chars.length));
+        }
+        return result;
+    };
+    /**
+     * Create a token manager for automatic token refresh
+     * @param config - Token manager configuration
+     * @returns Token manager instance
+     *
+     * @example
+     * ```typescript
+     * const client = new ApiClient();
+     *
+     * const tokenManager = client.authMethods.createTokenManager({
+     *     accessToken: 'current_access_token',
+     *     refreshToken: 'current_refresh_token',
+     *     expiresAt: 1234567890
+     * });
+     *
+     * // Get valid token (auto-refreshes if needed and updates client)
+     * const validToken = await tokenManager.getValidToken();
+     *
+     * // Client is now updated with fresh token - make API calls
+     * const content = await client.contentMethods.getContentItem(123, guid, locale);
+     * ```
+     */
+    AuthMethods.prototype.createTokenManager = function (config) {
+        return new TokenManager(this, config);
+    };
+    /**
+     * Get current authentication state
+     * @param token - Current access token
+     * @param expiresAt - Token expiration timestamp
+     * @param refreshToken - Optional refresh token
+     * @returns Authentication state information
+     *
+     * @example
+     * ```typescript
+     * const client = new ApiClient();
+     *
+     * const authState = client.authMethods.getAuthState(
+     *     localStorage.getItem('access_token'),
+     *     parseInt(localStorage.getItem('token_expires_at')),
+     *     localStorage.getItem('refresh_token')
+     * );
+     *
+     * if (authState.isAuthenticated) {
+     *     console.log('User is authenticated');
+     * } else {
+     *     console.log('User needs to authenticate');
+     * }
+     * ```
+     */
+    AuthMethods.prototype.getAuthState = function (token, expiresAt, refreshToken) {
+        if (!token) {
+            return { isAuthenticated: false };
+        }
+        var isExpired = expiresAt ? this.isTokenExpired(expiresAt) : false;
+        return {
+            isAuthenticated: !isExpired,
+            token: token,
+            expiresAt: expiresAt,
+            refreshToken: refreshToken
+        };
+    };
+    return AuthMethods;
+}());
+exports.AuthMethods = AuthMethods;
+/**
+ * Token manager class for automatic token refresh
+ */
+var TokenManager = /** @class */ (function () {
+    function TokenManager(authMethods, config) {
+        this.authMethods = authMethods;
+        this.config = config;
+    }
+    /**
+     * Get a valid access token, refreshing if necessary
+     * This automatically updates the shared token in the AuthMethods instance
+     * @returns Promise containing valid access token
+     */
+    TokenManager.prototype.getValidToken = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var validToken, newTokens, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.authMethods.getValidAccessToken()];
+                    case 1:
+                        validToken = _a.sent();
+                        if (validToken) {
+                            return [2 /*return*/, validToken];
+                        }
+                        // Fallback to old config-based approach for backwards compatibility
+                        if (this.config.expiresAt && !this.authMethods.isTokenExpired(this.config.expiresAt)) {
+                            return [2 /*return*/, this.config.accessToken];
+                        }
+                        if (!this.config.refreshToken) return [3 /*break*/, 5];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.authMethods.refreshAccessToken({
+                                refreshToken: this.config.refreshToken
+                            }, this.config.region)];
+                    case 3:
+                        newTokens = _a.sent();
+                        // Update configuration with new tokens
+                        this.config.accessToken = newTokens.access_token;
+                        this.config.expiresAt = this.authMethods.calculateExpirationTime(newTokens.expires_in);
+                        if (newTokens.refresh_token) {
+                            this.config.refreshToken = newTokens.refresh_token;
+                        }
+                        return [2 /*return*/, this.config.accessToken];
+                    case 4:
+                        error_2 = _a.sent();
+                        throw new exception_1.Exception('Token refresh failed - user needs to re-authenticate', error_2);
+                    case 5: throw new exception_1.Exception('No refresh token available - user needs to re-authenticate');
+                }
+            });
+        });
+    };
+    /**
+     * Update the token configuration
+     * @param config - New token configuration
+     */
+    TokenManager.prototype.updateConfig = function (config) {
+        this.config = __assign(__assign({}, this.config), config);
+    };
+    /**
+     * Get current token configuration
+     * @returns Current token configuration
+     */
+    TokenManager.prototype.getConfig = function () {
+        return __assign({}, this.config);
+    };
+    return TokenManager;
+}());
+exports.TokenManager = TokenManager;

package/dist/apiMethods/batchMethods.d.ts

@@ -1,11 +1,42 @@
 import { Options } from "../models/options";
 import { ClientInstance } from "./clientInstance";
 import { Batch } from "../models/batch";
+import { BatchTypesResponse } from "../models/batchTypes";
 export declare class BatchMethods {
     _options: Options;
     _clientInstance: ClientInstance;
     constructor(options: Options);
-    getBatch(batchID: number): Promise<Batch>;
+    getBatch(batchID: number, guid: string, expandItems?: boolean): Promise<Batch>;
+    publishBatch(batchID: number, guid: string, returnBatchId?: boolean): Promise<number>;
+    unpublishBatch(batchID: number, guid: string, returnBatchId?: boolean): Promise<number>;
+    approveBatch(batchID: number, guid: string, returnBatchId?: boolean): Promise<number>;
+    declineBatch(batchID: number, guid: string, returnBatchId?: boolean): Promise<number>;
+    requestApprovalBatch(batchID: number, guid: string, returnBatchId?: boolean): Promise<number>;
+    /**
+     * Retrieves all batch-related enum types for developer discovery.
+     * This method provides all available enum values with their names,
+     * enabling dynamic UI population and client-side validation.
+     *
+     * @param guid - Current website guid
+     * @returns Promise containing all batch enum types
+     *
+     * @example
+     * ```typescript
+     * // Get all batch types for UI population
+     * const types = await client.batchMethods.getBatchTypes(guid);
+     *
+     * // Create dropdown options for item types
+     * const itemTypeOptions = types.itemTypes.map(type => ({
+     *   label: type.name,
+     *   value: type.value
+     * }));
+     *
+     * // Validate operation type
+     * const isValidOperation = (value: number) =>
+     *   types.workflowOperations.some(op => op.value === value);
+     * ```
+     */
+    getBatchTypes(guid: string): Promise<BatchTypesResponse>;
     Retry(method: Function): Promise<Batch>;
     delay(ms: number): Promise<unknown>;
 }