@coinbase-sample/prime-sdk-ts 0.6.3 → 0.6.4

package/dist/shared/fieldMapping.js

@@ -0,0 +1,242 @@
+"use strict";
+/**
+ * Copyright 2025-present Coinbase Global, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFieldNameVariations = getFieldNameVariations;
+exports.extractContextClues = extractContextClues;
+exports.findEnumWithContext = findEnumWithContext;
+exports.findEnumByFieldName = findEnumByFieldName;
+exports.getDirectEnumMapping = getDirectEnumMapping;
+/**
+ * Field-to-enum mapping logic for dynamic enum detection
+ */
+const enumRegistry_1 = require("./enumRegistry");
+const serviceContext_1 = require("./serviceContext");
+/**
+ * Generate field name variations for plural/singular matching
+ */
+function getFieldNameVariations(fieldName) {
+    const variations = [fieldName];
+    // Handle irregular plurals and common patterns
+    const irregularPlurals = {
+        categories: 'category',
+        statuses: 'status',
+        activities: 'activity',
+        entities: 'entity',
+        currencies: 'currency',
+        portfolios: 'portfolio',
+    };
+    const irregularSingulars = {
+        category: 'categories',
+        status: 'statuses',
+        activity: 'activities',
+        entity: 'entities',
+        currency: 'currencies',
+        portfolio: 'portfolios',
+    };
+    // Check irregular mappings first
+    if (irregularPlurals[fieldName]) {
+        variations.push(irregularPlurals[fieldName]);
+    }
+    if (irregularSingulars[fieldName]) {
+        variations.push(irregularSingulars[fieldName]);
+    }
+    // Handle regular -s plurals only if not already handled by irregular rules
+    if (!irregularPlurals[fieldName] && !irregularSingulars[fieldName]) {
+        if (fieldName.endsWith('s') && fieldName.length > 3) {
+            // Remove 's' for potential singular
+            const singular = fieldName.slice(0, -1);
+            // Avoid cases like "address" -> "addres"
+            if (!singular.endsWith('s')) {
+                variations.push(singular);
+            }
+        }
+        else {
+            // Add regular plural
+            variations.push(fieldName + 's');
+        }
+    }
+    return variations;
+}
+/**
+ * Extract context clues from field names to resolve enum ambiguity
+ */
+function extractContextClues(fieldName) {
+    const clues = [];
+    const fieldLower = fieldName.toLowerCase();
+    // Extract prefix context (e.g., "activitystatus" → ["activity"])
+    const prefixMatch = fieldLower.match(/^([a-z]+?)(?:status|type|category)$/);
+    if (prefixMatch) {
+        clues.push(prefixMatch[1]);
+    }
+    // Extract camelCase components (e.g., "activityStatus" → ["activity"])
+    const camelComponents = fieldName
+        .replace(/([A-Z])/g, '_$1')
+        .toLowerCase()
+        .split('_')
+        .filter(Boolean);
+    clues.push(...camelComponents.slice(0, -1)); // Exclude the last component (status/type/category)
+    // Extract underscore/dash separated components
+    const separatedComponents = fieldName.toLowerCase().split(/[_-]+/);
+    clues.push(...separatedComponents.slice(0, -1));
+    return [...new Set(clues)]; // Remove duplicates
+}
+/**
+ * Find enum with context awareness to resolve collisions
+ */
+function findEnumWithContext(fieldName, allEnumNames) {
+    // Handle ambiguous suffixes that appear in multiple enums
+    const ambiguousSuffixes = ['status', 'type', 'category'];
+    const fieldLower = fieldName.toLowerCase();
+    // Check if this is an ambiguous field name
+    const isAmbiguous = ambiguousSuffixes.some((suffix) => fieldLower.endsWith(suffix) || fieldLower === suffix);
+    if (isAmbiguous) {
+        // For ambiguous cases, look for context clues in the field name
+        const contextClues = extractContextClues(fieldName);
+        // Find enum that best matches the context
+        const matches = allEnumNames.filter((enumName) => {
+            const enumLower = enumName.toLowerCase();
+            // Exact compound match (e.g., "activitystatus" → "ActivityStatus")
+            if (enumLower === fieldLower)
+                return true;
+            // Context-based matching
+            for (const clue of contextClues) {
+                if (enumLower.includes(clue) &&
+                    enumLower.endsWith(fieldLower.split(/(?=[a-z])/).pop() || '')) {
+                    return true;
+                }
+            }
+            return false;
+        });
+        // Return the most specific match
+        if (matches.length === 1) {
+            return matches[0];
+        }
+        // If multiple matches, prefer the longest/most specific one
+        if (matches.length > 1) {
+            return matches.reduce((longest, current) => current.length > longest.length ? current : longest);
+        }
+    }
+    // Non-ambiguous cases: use careful substring matching
+    // Sort enums by name length (shortest first) to prefer simpler matches
+    const sortedEnumNames = allEnumNames
+        .slice()
+        .sort((a, b) => a.length - b.length);
+    for (const enumName of sortedEnumNames) {
+        const enumNameLower = enumName.toLowerCase();
+        // Only match if field name is a meaningful part of the enum name
+        // Avoid greedy matches like "side" matching "FcmPositionSide"
+        if (enumNameLower === fieldLower) {
+            return enumName; // Exact match
+        }
+        // Check if field name appears as a word boundary in enum name
+        // e.g., "side" should match "OrderSide" but not "FcmPositionSide"
+        const wordBoundaryRegex = new RegExp(`\\b${fieldLower}\\b`, 'i');
+        if (wordBoundaryRegex.test(enumName)) {
+            return enumName;
+        }
+        // Check for field name at the end of enum name (most common pattern)
+        if (enumNameLower.endsWith(fieldLower) && enumNameLower !== fieldLower) {
+            // Ensure it's not a substring within a word
+            const beforeField = enumNameLower.slice(0, -fieldLower.length);
+            if (beforeField.length > 0 && /[a-z]$/.test(beforeField)) {
+                continue; // Skip if it's part of a word
+            }
+            return enumName;
+        }
+    }
+    return null;
+}
+/**
+ * Dynamically find enum name based on field name patterns
+ */
+function findEnumByFieldName(fieldName) {
+    const allEnumNames = enumRegistry_1.enumRegistry.getAllEnumNames();
+    // Strategy 1: Direct name match (e.g., "ActivityCategory" field → "ActivityCategory" enum)
+    const exactMatch = allEnumNames.find((enumName) => enumName.toLowerCase() === fieldName.toLowerCase());
+    if (exactMatch)
+        return exactMatch;
+    // Strategy 2: Smart plural/singular variations
+    const variations = getFieldNameVariations(fieldName);
+    for (const enumName of allEnumNames) {
+        const enumNameLower = enumName.toLowerCase();
+        if (variations.includes(enumNameLower)) {
+            return enumName;
+        }
+    }
+    // Strategy 3: Context-aware enum matching (handles collisions)
+    const contextMatch = findEnumWithContext(fieldName, allEnumNames);
+    if (contextMatch) {
+        return contextMatch;
+    }
+    // Strategy 4: Smart pattern matching for compound field names
+    // Handle cases like "activitycategory" → "ActivityCategory"
+    for (const enumName of allEnumNames) {
+        const enumWords = enumName
+            .toLowerCase()
+            .replace(/([A-Z])/g, ' $1')
+            .trim()
+            .split(' ');
+        const fieldWords = fieldName
+            .replace(/([A-Z])/g, ' $1')
+            .trim()
+            .split(/[\s_-]+/);
+        // Check if all field words are contained in enum words
+        const allWordsMatch = fieldWords.every((word) => enumWords.some((enumWord) => enumWord.includes(word) || word.includes(enumWord)));
+        if (allWordsMatch && fieldWords.length > 1) {
+            return enumName;
+        }
+    }
+    return null;
+}
+/**
+ * Get direct field-to-enum mapping with service context and fallback to essential mappings
+ */
+function getDirectEnumMapping(fieldName, serviceName) {
+    const fieldNameLower = fieldName.toLowerCase();
+    // First priority: Service context-specific mapping
+    if (serviceName) {
+        const serviceMapping = (0, serviceContext_1.resolveFieldWithServiceContext)(fieldName, serviceName);
+        if (serviceMapping) {
+            return serviceMapping;
+        }
+    }
+    // Second priority: Dynamic enum name matching
+    const dynamicMatch = findEnumByFieldName(fieldNameLower);
+    if (dynamicMatch) {
+        return dynamicMatch;
+    }
+    // Fall back to essential manual mappings for common patterns that don't follow naming conventions
+    // These should be conservative and only include non-ambiguous cases
+    const essentialMappings = {
+        // Common trading/order fields (most frequent use case)
+        side: 'OrderSide',
+        status: 'OrderStatus', // Default to OrderStatus, validation will catch mismatches
+        role: 'UserRole',
+        action: 'Action',
+        direction: 'SortDirection',
+        // Specific compound fields to prevent wrong mappings
+        orderside: 'OrderSide',
+        ordertype: 'OrderType',
+        orderstatus: 'OrderStatus',
+        wallettype: 'WalletType',
+        transactiontype: 'TransactionType',
+        activitytype: 'CustodyActivityType',
+        activitystatus: 'ActivityStatus',
+        // Note: 'type' still removed (too ambiguous - let value-based detection handle it)
+    };
+    return essentialMappings[fieldNameLower] || null;
+}

package/dist/shared/serviceContext.js

@@ -0,0 +1,157 @@
+"use strict";
+/**
+ * Copyright 2025-present Coinbase Global, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SERVICE_CONTEXTS = void 0;
+exports.getServiceContext = getServiceContext;
+exports.resolveFieldWithServiceContext = resolveFieldWithServiceContext;
+exports.getAllServiceContexts = getAllServiceContexts;
+exports.hasServiceContext = hasServiceContext;
+/**
+ * Registry of service contexts for accurate enum detection
+ */
+exports.SERVICE_CONTEXTS = {
+    // Activities Service
+    activities: {
+        serviceName: 'ActivitiesService',
+        fieldMappings: {
+            status: 'ActivityStatus',
+            type: 'CustodyActivityType',
+            category: 'ActivityCategory',
+            categories: 'ActivityCategory',
+            secondaryType: 'ActivitySecondaryType',
+        },
+        description: 'Portfolio and entity activity operations',
+    },
+    // Orders Service
+    orders: {
+        serviceName: 'OrdersService',
+        fieldMappings: {
+            status: 'OrderStatus',
+            type: 'OrderType',
+            side: 'OrderSide',
+            timeInForce: 'TimeInForceType',
+        },
+        description: 'Trading order operations',
+    },
+    // Transactions Service
+    transactions: {
+        serviceName: 'TransactionsService',
+        fieldMappings: {
+            status: 'TransactionStatus',
+            type: 'TransactionType',
+            destinationType: 'DestinationType',
+        },
+        description: 'Transaction and transfer operations',
+    },
+    // Wallets Service
+    wallets: {
+        serviceName: 'WalletsService',
+        fieldMappings: {
+            type: 'WalletType',
+            status: 'WalletStatus',
+        },
+        description: 'Wallet management operations',
+    },
+    // Allocations Service
+    allocations: {
+        serviceName: 'AllocationsService',
+        fieldMappings: {
+            status: 'AllocationStatus',
+            type: 'AllocationType',
+        },
+        description: 'Portfolio allocation operations',
+    },
+    // Users Service
+    users: {
+        serviceName: 'UsersService',
+        fieldMappings: {
+            role: 'UserRole',
+            status: 'UserStatus',
+        },
+        description: 'User management operations',
+    },
+    // Balances Service
+    balances: {
+        serviceName: 'BalancesService',
+        fieldMappings: {
+            type: 'PortfolioBalanceType',
+        },
+        description: 'Balance and portfolio operations',
+    },
+    // Portfolios Service
+    portfolios: {
+        serviceName: 'PortfoliosService',
+        fieldMappings: {
+            type: 'PortfolioType',
+            status: 'PortfolioStatus',
+        },
+        description: 'Portfolio management operations',
+    },
+    // Products Service
+    products: {
+        serviceName: 'ProductsService',
+        fieldMappings: {
+            type: 'ProductType',
+            permissions: 'ProductPermissions',
+            category: 'ProductCategory',
+        },
+        description: 'Product and market data operations',
+    },
+    // Assets Service
+    assets: {
+        serviceName: 'AssetsService',
+        fieldMappings: {
+            type: 'AssetType',
+            status: 'AssetStatus',
+        },
+        description: 'Asset management operations',
+    },
+};
+/**
+ * Get service context by service name
+ */
+function getServiceContext(serviceName) {
+    // Normalize service name (remove "Service" suffix if present)
+    const normalizedName = serviceName.toLowerCase().replace(/service$/, '');
+    return exports.SERVICE_CONTEXTS[normalizedName] || null;
+}
+/**
+ * Resolve field to enum using service context
+ */
+function resolveFieldWithServiceContext(fieldName, serviceName) {
+    if (!serviceName) {
+        return null;
+    }
+    const context = getServiceContext(serviceName);
+    if (!context) {
+        return null;
+    }
+    const fieldLower = fieldName.toLowerCase();
+    return context.fieldMappings[fieldLower] || null;
+}
+/**
+ * Get all available service contexts
+ */
+function getAllServiceContexts() {
+    return Object.assign({}, exports.SERVICE_CONTEXTS);
+}
+/**
+ * Check if a service has context defined
+ */
+function hasServiceContext(serviceName) {
+    return getServiceContext(serviceName) !== null;
+}

package/dist/types/balances/types.d.ts

@@ -19,7 +19,7 @@ import { GetPortfolioBalancesResponse, GetWalletBalanceResponse as internalGetRe
 import { BasePaginatedRequest, PaginatedResponseMethods } from '../shared/paginatedResponse';
 export type ListPortfolioBalancesRequest = {
     portfolioId: string;
-    symbol: string;
+    symbols?: string[];
     balanceType?: PortfolioBalanceType;
 };
 export type ListPortfolioBalancesResponse = Brand<GetPortfolioBalancesResponse, 'ListPortfolioBalancesResponse'>;

package/dist/types/constants.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export declare const VERSION = "0.6.3";
+export declare const VERSION = "0.6.4";
 export declare const API_BASE_PATH = "https://api.prime.coinbase.com/v1/";
 export declare const USER_AGENT: string;
 export declare const CB_ACCESS_KEY_HEADER = "X-CB-ACCESS-KEY";

package/dist/types/model/enumPrefixes.d.ts

@@ -0,0 +1,206 @@
+/**
+ * Copyright 2025-present Coinbase Global, Inc.
+ *
+ * This file is auto-generated during the type generation process.
+ * Do not edit manually - regenerate by running: npm run generate-types
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Auto-generated enum prefix patterns extracted from OpenAPI specification
+ * Total enums analyzed: 43
+ * Prefix patterns discovered: 77
+ */
+export declare const GENERATED_ENUM_PREFIXES: readonly ["ACTION_", "ACTIVITY_CATEGORY_", "ACTIVITY_LEVEL_", "ACTIVITY_SECONDARY_", "ACTIVITY_STATUS_", "ACTIVITY_TYPE_", "ADDRESS_BOOK_", "ALLOCATION_STATUS_", "BALANCE_", "BENCHMARK_", "BILATERAL_", "BILLING_", "CHANGE_", "CLAIM_", "COINBASE_", "COMPLETE_", "CONCENTRATION_", "COUNTERPARTY_", "CRYPTO_", "DEPOSIT_", "DESTINATION_", "DESTINATION_PAYMENT_", "FCM_FUTURES_", "FCM_MARGIN_", "FCM_POSITION_", "FILL_OR_", "FULL_", "GOOD_UNTIL_", "HIERARCHY_TYPE_", "IMMEDIATE_OR_", "INTERNAL_", "INVOICE_STATE_", "INVOICE_TYPE_", "ITEM_", "ITEM_APPROVAL_", "LOAN_TYPE_", "MACRO_", "MARGIN_ADD_", "METHOD_", "MULTIPLE_", "NETWORK_FAMILY_", "NETWORK_TYPE_", "NO_SECONDARY_", "ONCHAIN_", "OTHER_", "OTHER_ACTIVITY_", "OTHER_TRANSACTION_", "PAYMENT_", "PORTFOLIO_", "POSITION_REFERENCE_", "PRIME_CUSTODY_", "PRODUCT_PERMISSION_", "PROXY_", "RATE_TYPE_", "REMOVE_AUTHORIZED_", "SHORT_", "SHORT_BIASED_", "SHORT_COLLATERAL_", "SINGLE_COIN_", "STAKE_ACCOUNT_", "STAKE_AUTHORIZE_", "STOP_", "SWEEP_", "TEAM_", "TOTAL_", "TRADE_", "TRADING_", "TRANSACTION_", "TRANSACTION_IMPORT_", "TRANSACTION_TYPE_", "UNIFIED_TOTAL_", "VAULT_", "VOTE_", "WALLET_TYPE_", "WALLET_VISIBILITY_", "WITHDRAWAL_", "WITHDRAW_"];
+/**
+ * Detailed enum analysis for debugging and insights
+ */
+export declare const ENUM_ANALYSIS: {
+    readonly totalEnums: 43;
+    readonly discoveredPrefixes: 77;
+    readonly prefixPatterns: readonly ["ACTION_", "ACTIVITY_CATEGORY_", "ACTIVITY_LEVEL_", "ACTIVITY_SECONDARY_", "ACTIVITY_STATUS_", "ACTIVITY_TYPE_", "ADDRESS_BOOK_", "ALLOCATION_STATUS_", "BALANCE_", "BENCHMARK_", "BILATERAL_", "BILLING_", "CHANGE_", "CLAIM_", "COINBASE_", "COMPLETE_", "CONCENTRATION_", "COUNTERPARTY_", "CRYPTO_", "DEPOSIT_", "DESTINATION_", "DESTINATION_PAYMENT_", "FCM_FUTURES_", "FCM_MARGIN_", "FCM_POSITION_", "FILL_OR_", "FULL_", "GOOD_UNTIL_", "HIERARCHY_TYPE_", "IMMEDIATE_OR_", "INTERNAL_", "INVOICE_STATE_", "INVOICE_TYPE_", "ITEM_", "ITEM_APPROVAL_", "LOAN_TYPE_", "MACRO_", "MARGIN_ADD_", "METHOD_", "MULTIPLE_", "NETWORK_FAMILY_", "NETWORK_TYPE_", "NO_SECONDARY_", "ONCHAIN_", "OTHER_", "OTHER_ACTIVITY_", "OTHER_TRANSACTION_", "PAYMENT_", "PORTFOLIO_", "POSITION_REFERENCE_", "PRIME_CUSTODY_", "PRODUCT_PERMISSION_", "PROXY_", "RATE_TYPE_", "REMOVE_AUTHORIZED_", "SHORT_", "SHORT_BIASED_", "SHORT_COLLATERAL_", "SINGLE_COIN_", "STAKE_ACCOUNT_", "STAKE_AUTHORIZE_", "STOP_", "SWEEP_", "TEAM_", "TOTAL_", "TRADE_", "TRADING_", "TRANSACTION_", "TRANSACTION_IMPORT_", "TRANSACTION_TYPE_", "UNIFIED_TOTAL_", "VAULT_", "VOTE_", "WALLET_TYPE_", "WALLET_VISIBILITY_", "WITHDRAWAL_", "WITHDRAW_"];
+    readonly enumDetails: readonly [{
+        readonly name: "CoinbaseCustodyApiActivityType";
+        readonly valueCount: 29;
+        readonly file: "coinbaseCustodyApiActivityType.ts";
+    }, {
+        readonly name: "CoinbaseCustodyApiAddressBookType";
+        readonly valueCount: 3;
+        readonly file: "coinbaseCustodyApiAddressBookType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiAction";
+        readonly valueCount: 5;
+        readonly file: "coinbasePublicRestApiAction.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiActivityCategory";
+        readonly valueCount: 7;
+        readonly file: "coinbasePublicRestApiActivityCategory.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiActivityLevel";
+        readonly valueCount: 3;
+        readonly file: "coinbasePublicRestApiActivityLevel.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiActivitySecondaryType";
+        readonly valueCount: 7;
+        readonly file: "coinbasePublicRestApiActivitySecondaryType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiActivityStatus";
+        readonly valueCount: 7;
+        readonly file: "coinbasePublicRestApiActivityStatus.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiActivityType";
+        readonly valueCount: 42;
+        readonly file: "coinbasePublicRestApiActivityType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiAllocationSizeType";
+        readonly valueCount: 3;
+        readonly file: "coinbasePublicRestApiAllocationSizeType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiAllocationStatus";
+        readonly valueCount: 5;
+        readonly file: "coinbasePublicRestApiAllocationStatus.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiAssetChangeType";
+        readonly valueCount: 5;
+        readonly file: "coinbasePublicRestApiAssetChangeType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiBenchmark";
+        readonly valueCount: 5;
+        readonly file: "coinbasePublicRestApiBenchmark.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiDestinationType";
+        readonly valueCount: 4;
+        readonly file: "coinbasePublicRestApiDestinationType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiFcmFuturesSweepStatus";
+        readonly valueCount: 5;
+        readonly file: "coinbasePublicRestApiFcmFuturesSweepStatus.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiFcmMarginCallState";
+        readonly valueCount: 5;
+        readonly file: "coinbasePublicRestApiFcmMarginCallState.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiFcmMarginCallType";
+        readonly valueCount: 3;
+        readonly file: "coinbasePublicRestApiFcmMarginCallType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiFcmPositionSide";
+        readonly valueCount: 3;
+        readonly file: "coinbasePublicRestApiFcmPositionSide.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiHierarchyType";
+        readonly valueCount: 3;
+        readonly file: "coinbasePublicRestApiHierarchyType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiInvoiceState";
+        readonly valueCount: 5;
+        readonly file: "coinbasePublicRestApiInvoiceState.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiInvoiceType";
+        readonly valueCount: 6;
+        readonly file: "coinbasePublicRestApiInvoiceType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiLoanType";
+        readonly valueCount: 6;
+        readonly file: "coinbasePublicRestApiLoanType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiMarginAddOnType";
+        readonly valueCount: 5;
+        readonly file: "coinbasePublicRestApiMarginAddOnType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiNetworkFamily";
+        readonly valueCount: 3;
+        readonly file: "coinbasePublicRestApiNetworkFamily.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiNetworkType";
+        readonly valueCount: 3;
+        readonly file: "coinbasePublicRestApiNetworkType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiOrderSide";
+        readonly valueCount: 2;
+        readonly file: "coinbasePublicRestApiOrderSide.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiOrderStatus";
+        readonly valueCount: 6;
+        readonly file: "coinbasePublicRestApiOrderStatus.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiOrderType";
+        readonly valueCount: 7;
+        readonly file: "coinbasePublicRestApiOrderType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiPaymentMethodType";
+        readonly valueCount: 3;
+        readonly file: "coinbasePublicRestApiPaymentMethodType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiPortfolioBalanceType";
+        readonly valueCount: 5;
+        readonly file: "coinbasePublicRestApiPortfolioBalanceType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiPositionReferenceType";
+        readonly valueCount: 3;
+        readonly file: "coinbasePublicRestApiPositionReferenceType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiProductPermissions";
+        readonly valueCount: 3;
+        readonly file: "coinbasePublicRestApiProductPermissions.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiRateType";
+        readonly valueCount: 5;
+        readonly file: "coinbasePublicRestApiRateType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiSigningStatus";
+        readonly valueCount: 2;
+        readonly file: "coinbasePublicRestApiSigningStatus.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiSortDirection";
+        readonly valueCount: 2;
+        readonly file: "coinbasePublicRestApiSortDirection.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiTimeInForceType";
+        readonly valueCount: 4;
+        readonly file: "coinbasePublicRestApiTimeInForceType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiTransactionStatus";
+        readonly valueCount: 21;
+        readonly file: "coinbasePublicRestApiTransactionStatus.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiTransactionType";
+        readonly valueCount: 33;
+        readonly file: "coinbasePublicRestApiTransactionType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiTransferLocationType";
+        readonly valueCount: 6;
+        readonly file: "coinbasePublicRestApiTransferLocationType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiUserRole";
+        readonly valueCount: 9;
+        readonly file: "coinbasePublicRestApiUserRole.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiVisibilityStatus";
+        readonly valueCount: 3;
+        readonly file: "coinbasePublicRestApiVisibilityStatus.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiWalletDepositInstructionType";
+        readonly valueCount: 5;
+        readonly file: "coinbasePublicRestApiWalletDepositInstructionType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiWalletType";
+        readonly valueCount: 5;
+        readonly file: "coinbasePublicRestApiWalletType.ts";
+    }, {
+        readonly name: "CoinbasePublicRestApiWalletVisibility";
+        readonly valueCount: 3;
+        readonly file: "coinbasePublicRestApiWalletVisibility.ts";
+    }];
+};
+export type EnumPrefix = (typeof GENERATED_ENUM_PREFIXES)[number];

package/dist/types/paymentMethods/types.d.ts

@@ -21,5 +21,6 @@ export type ListEntityPaymentMethodsRequest = {
 export type ListEntityPaymentMethodsResponse = Brand<GetEntityPaymentMethodsResponse, 'ListEntityPaymentMethodsResponse'>;
 export type GetPaymentMethodRequest = {
     entityId: string;
+    paymentMethodId: string;
 };
 export type GetPaymentMethodResponse = Brand<GetEntityPaymentMethodDetailsResponse, 'GetPaymentMethodResponse'>;