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

package/dist/types/shared/enumHelpers.d.ts

@@ -0,0 +1,135 @@
+/**
+ * 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.
+ */
+/**
+ * Enum transformation utilities for JavaScript developers.
+ * These helpers make it easier to work with enums by providing:
+ * - Case-insensitive enum lookups
+ * - CamelCase to SNAKE_CASE conversion
+ * - Enum validation with helpful error messages
+ * - Support for prefix-aware transformations
+ */
+/**
+ * Converts a string from various formats to the expected enum value format (SCREAMING_SNAKE_CASE)
+ *
+ * @param input - The input string in any case format
+ * @returns The normalized SCREAMING_SNAKE_CASE string
+ *
+ * @example
+ * normalizeEnumValue('buy') // 'BUY'
+ * normalizeEnumValue('marketOrder') // 'MARKET_ORDER'
+ * normalizeEnumValue('STOP_LIMIT') // 'STOP_LIMIT'
+ * normalizeEnumValue('Order_Type_Market') // 'ORDER_TYPE_MARKET'
+ */
+export declare function normalizeEnumValue(input: string): string;
+/**
+ * Safely gets an enum value by normalizing the input and checking if it exists
+ *
+ * @param enumObject - The enum object to search in
+ * @param input - The input value to normalize and find
+ * @param enumName - Optional enum name for better error messages
+ * @returns The matching enum value or undefined if not found
+ *
+ * @example
+ * import { OrderSide } from '../model/enums/OrderSide';
+ *
+ * getEnumValue(OrderSide, 'buy') // OrderSide.Buy
+ * getEnumValue(OrderSide, 'BUY') // OrderSide.Buy
+ * getEnumValue(OrderSide, 'invalid') // undefined
+ */
+export declare function getEnumValue<T extends Record<string, string>>(enumObject: T, input: string, enumName?: string): T[keyof T] | undefined;
+/**
+ * Gets an enum value with strict validation, throwing an error if not found
+ *
+ * @param enumObject - The enum object to search in
+ * @param input - The input value to normalize and find
+ * @param enumName - Optional enum name for better error messages
+ * @returns The matching enum value
+ * @throws Error if the enum value is not found
+ *
+ * @example
+ * import { OrderSide } from '../model/enums/OrderSide';
+ *
+ * requireEnumValue(OrderSide, 'buy') // OrderSide.Buy
+ * requireEnumValue(OrderSide, 'invalid') // throws Error
+ */
+export declare function requireEnumValue<T extends Record<string, string>>(enumObject: T, input: string, enumName?: string): T[keyof T];
+/**
+ * Checks if a string is a valid enum value (case-insensitive)
+ *
+ * @param enumObject - The enum object to check against
+ * @param input - The input value to validate
+ * @returns True if the input is a valid enum value
+ *
+ * @example
+ * import { OrderSide } from '../model/enums/OrderSide';
+ *
+ * isValidEnumValue(OrderSide, 'buy') // true
+ * isValidEnumValue(OrderSide, 'BUY') // true
+ * isValidEnumValue(OrderSide, 'invalid') // false
+ */
+export declare function isValidEnumValue<T extends Record<string, string>>(enumObject: T, input: string): boolean;
+/**
+ * Gets all possible enum values as an array
+ *
+ * @param enumObject - The enum object
+ * @returns Array of all enum values
+ *
+ * @example
+ * import { OrderSide } from '../model/enums/OrderSide';
+ *
+ * getEnumValues(OrderSide) // ['BUY', 'SELL']
+ */
+export declare function getEnumValues<T extends Record<string, string>>(enumObject: T): T[keyof T][];
+/**
+ * Gets all possible enum keys as an array
+ *
+ * @param enumObject - The enum object
+ * @returns Array of all enum keys
+ *
+ * @example
+ * import { OrderSide } from '../model/enums/OrderSide';
+ *
+ * getEnumKeys(OrderSide) // ['Buy', 'Sell']
+ */
+export declare function getEnumKeys<T extends Record<string, string>>(enumObject: T): (keyof T)[];
+/**
+ * Validates that a string has the correct prefix for enum values
+ * Useful for ensuring enum values follow expected patterns
+ *
+ * @param input - The enum value to check
+ * @param expectedPrefix - The expected prefix (e.g., 'ORDER_TYPE_', 'ACTIVITY_TYPE_')
+ * @param strict - If true, requires exact prefix match. If false, allows values without prefix
+ * @returns True if the prefix is correct
+ *
+ * @example
+ * validateEnumPrefix('ORDER_TYPE_MARKET', 'ORDER_TYPE_') // true
+ * validateEnumPrefix('MARKET', 'ORDER_TYPE_', false) // true (non-strict)
+ * validateEnumPrefix('MARKET', 'ORDER_TYPE_', true) // false (strict)
+ */
+export declare function validateEnumPrefix(input: string, expectedPrefix: string, strict?: boolean): boolean;
+/**
+ * Transforms enum input to the correct format, optionally adding a prefix
+ *
+ * @param input - The input string
+ * @param prefix - Optional prefix to add if not present
+ * @returns The transformed enum value
+ *
+ * @example
+ * transformEnumValue('market', 'ORDER_TYPE_') // 'ORDER_TYPE_MARKET'
+ * transformEnumValue('ORDER_TYPE_MARKET', 'ORDER_TYPE_') // 'ORDER_TYPE_MARKET'
+ * transformEnumValue('marketOrder') // 'MARKET_ORDER'
+ */
+export declare function transformEnumValue(input: string, prefix?: string): string;

package/dist/types/shared/enumRegistry.d.ts

@@ -0,0 +1,74 @@
+/**
+ * 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.
+ */
+/**
+ * Registry for managing discovered enums and providing lookup capabilities
+ */
+export declare class EnumRegistry {
+    private enums;
+    private enumsByValue;
+    private enumsByKey;
+    constructor();
+    /**
+     * Automatically discover and register all enums from the model/enums directory
+     */
+    private populateEnums;
+    /**
+     * Check if an object is a valid TypeScript enum
+     */
+    private isValidEnum;
+    /**
+     * Index enum values and keys for fast lookup
+     */
+    private indexEnumValues;
+    /**
+     * Get a specific enum by name
+     */
+    getEnum(enumName: string): Record<string, string> | null;
+    /**
+     * Get all registered enum names
+     */
+    getAllEnumNames(): string[];
+    /**
+     * Find enum by value (exact match)
+     */
+    findEnumByValue(value: string): {
+        enum: Record<string, string>;
+        name: string;
+    } | null;
+    /**
+     * Find enum by key (exact match)
+     */
+    findEnumByKey(key: string): {
+        enum: Record<string, string>;
+        name: string;
+    } | null;
+    /**
+     * Get statistics about discovered enums
+     */
+    getStats(): {
+        totalEnums: number;
+        totalValues: number;
+        totalKeys: number;
+    };
+    /**
+     * Get detailed information about all enums
+     */
+    getEnumDetails(): Record<string, {
+        values: string[];
+        keys: string[];
+    }>;
+}
+export declare const enumRegistry: EnumRegistry;

package/dist/types/shared/enumValidationCore.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 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.
+ */
+/**
+ * Error thrown when a request contains invalid enum values
+ */
+export declare class DynamicEnumValidationError extends Error {
+    field: string;
+    value: string;
+    enumName: string;
+    validValues: string[];
+    validKeys?: string[] | undefined;
+    constructor(field: string, value: string, enumName: string, validValues: string[], validKeys?: string[] | undefined);
+}
+/**
+ * Configuration for dynamic validation behavior
+ */
+export interface DynamicValidationConfig {
+    enabled: boolean;
+    strict: boolean;
+    autoNormalize: boolean;
+    logWarnings: boolean;
+    serviceName?: string;
+}
+/**
+ * Information about a field that contains enum values
+ */
+export interface FieldTypeInfo {
+    fieldName: string;
+    enumName: string;
+    isOptional: boolean;
+    isArray: boolean;
+}
+/**
+ * Check if a value is valid for a specific enum (includes normalization)
+ */
+export declare function isValueValidForEnum(value: string, enumObject: Record<string, string>): boolean;
+/**
+ * Detects the enum type for a field based on field name patterns and value analysis
+ */
+export declare function detectEnumType(fieldName: string, value: string, serviceName?: string): {
+    enum: Record<string, string>;
+    name: string;
+} | null;
+/**
+ * Analyzes a single field to determine if it's an enum
+ */
+export declare function analyzeField(fieldName: string, value: any, serviceName?: string): FieldTypeInfo | null;
+/**
+ * Validate and normalize a single enum value
+ */
+export declare function validateEnumValue(value: string, enumObject: Record<string, string>, enumName: string, fieldName: string, config: DynamicValidationConfig): {
+    isValid: boolean;
+    normalizedValue?: string;
+    error?: string;
+};

package/dist/types/shared/enumValidators.d.ts

@@ -0,0 +1,117 @@
+/**
+ * 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.
+ */
+/**
+ * Convenient enum validators for common Prime API enums.
+ * These provide pre-configured validation for frequently used enum types.
+ *
+ * Note: Most users should use the dynamic validation system instead, which
+ * automatically handles all enums. These validators are useful for explicit
+ * control or when you need to validate individual enum values.
+ */
+import { normalizeEnumValue } from './enumHelpers';
+import { OrderType } from '../model/enums/OrderType';
+import { OrderSide } from '../model/enums/OrderSide';
+import { OrderStatus } from '../model/enums/OrderStatus';
+import { TransactionType } from '../model/enums/TransactionType';
+import { TimeInForceType } from '../model/enums/TimeInForceType';
+/**
+ * Order-related enum helpers
+ */
+export declare const OrderEnums: {
+    /**
+     * Validates and normalizes order type values
+     * Accepts: 'market', 'limit', 'twap', 'block', 'vwap', 'stopLimit', 'rfq' (case-insensitive)
+     */
+    getOrderType: (input: string) => OrderType | undefined;
+    requireOrderType: (input: string) => OrderType;
+    isValidOrderType: (input: string) => boolean;
+    /**
+     * Validates and normalizes order side values
+     * Accepts: 'buy', 'sell' (case-insensitive)
+     */
+    getOrderSide: (input: string) => OrderSide | undefined;
+    requireOrderSide: (input: string) => OrderSide;
+    isValidOrderSide: (input: string) => boolean;
+    /**
+     * Validates and normalizes order status values
+     * Accepts: 'open', 'filled', 'cancelled', 'expired', 'failed', 'pending' (case-insensitive)
+     */
+    getOrderStatus: (input: string) => OrderStatus | undefined;
+    requireOrderStatus: (input: string) => OrderStatus;
+    isValidOrderStatus: (input: string) => boolean;
+    /**
+     * Validates and normalizes time in force type values
+     * Accepts: 'good_until_cancelled', 'good_until_time', 'immediate_or_cancel', 'fill_or_kill' (case-insensitive)
+     */
+    getTimeInForceType: (input: string) => TimeInForceType | undefined;
+    requireTimeInForceType: (input: string) => TimeInForceType;
+    isValidTimeInForceType: (input: string) => boolean;
+};
+/**
+ * Transaction-related enum helpers
+ */
+export declare const TransactionEnums: {
+    /**
+     * Validates and normalizes transaction type values
+     * Accepts various transaction types like 'deposit', 'withdrawal', 'internalDeposit', etc. (case-insensitive)
+     */
+    getTransactionType: (input: string) => TransactionType | undefined;
+    requireTransactionType: (input: string) => TransactionType;
+    isValidTransactionType: (input: string) => boolean;
+};
+/**
+ * Utility for creating custom enum validators for any enum type
+ *
+ * @param enumObject - The enum object to create validators for
+ * @param enumName - Name of the enum for error messages
+ * @returns Object with validation methods
+ *
+ * @example
+ * import { WalletType } from '../model/enums/WalletType';
+ *
+ * const WalletValidators = createEnumValidators(WalletType, 'WalletType');
+ * WalletValidators.get('trading'); // Gets WalletType value
+ * WalletValidators.require('custody'); // Gets WalletType value or throws
+ * WalletValidators.isValid('invalid'); // false
+ */
+export declare function createEnumValidators<T extends Record<string, string>>(enumObject: T, enumName: string): {
+    get: (input: string) => T[keyof T] | undefined;
+    require: (input: string) => T[keyof T];
+    isValid: (input: string) => boolean;
+    values: string[];
+    keys: string[];
+};
+/**
+ * Convenience function to normalize any string to enum format
+ * Useful for debugging or preparing values for API calls
+ *
+ * @example
+ * toEnumFormat('marketOrder') // 'MARKET_ORDER'
+ * toEnumFormat('buy') // 'BUY'
+ * toEnumFormat('stop-limit') // 'STOP_LIMIT'
+ */
+export { normalizeEnumValue as toEnumFormat };
+/**
+ * @deprecated Use the dynamic validation system instead.
+ *
+ * Most users should prefer:
+ * ```javascript
+ * import { dynamicValidateRequest } from '@coinbase/prime-sdk';
+ * const validated = dynamicValidateRequest(request);
+ * ```
+ *
+ * This provides automatic validation for all enum fields without manual configuration.
+ */

package/dist/types/shared/envUtils.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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.
+ */
+import { CoinbasePrimeCredentials } from '../credentials';
+/**
+ * Shared utility function to create credentials from environment variables
+ * Used by both CoinbasePrimeClient and CoinbasePrimeClientWithServices
+ *
+ * Automatically attempts to load .env file if dotenv is available.
+ * If dotenv is not installed or .env file doesn't exist, falls back to
+ * using environment variables set directly.
+ *
+ * @advanced For custom scenarios. Most users should use Client.fromEnv() instead.
+ * @example
+ * ```typescript
+ * // Basic usage (recommended)
+ * const client = CoinbasePrimeClient.fromEnv();
+ *
+ * // Advanced usage (custom scenarios)
+ * const credentials = createCredentialsFromEnv();
+ * const client = new CoinbasePrimeClient(credentials, 'custom-url');
+ * ```
+ */
+export declare function createCredentialsFromEnv(): CoinbasePrimeCredentials;

package/dist/types/shared/fieldMapping.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ */
+/**
+ * Generate field name variations for plural/singular matching
+ */
+export declare function getFieldNameVariations(fieldName: string): string[];
+/**
+ * Extract context clues from field names to resolve enum ambiguity
+ */
+export declare function extractContextClues(fieldName: string): string[];
+/**
+ * Find enum with context awareness to resolve collisions
+ */
+export declare function findEnumWithContext(fieldName: string, allEnumNames: string[]): string | null;
+/**
+ * Dynamically find enum name based on field name patterns
+ */
+export declare function findEnumByFieldName(fieldName: string): string | null;
+/**
+ * Get direct field-to-enum mapping with service context and fallback to essential mappings
+ */
+export declare function getDirectEnumMapping(fieldName: string, serviceName?: string): string | null;

package/dist/types/shared/paginatedResponse.d.ts

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { CoinbaseCallOptions } from '@coinbase-sample/core-ts';
-import { CoinbasePrimeClient } from 'src/client';
+import { CoinbaseCallOptions, IPrimeApiClient } from '../clients';
 import { SortDirection } from '../model/enums/SortDirection';
 /**
  * Base type for paginated requests
@@ -118,5 +117,5 @@ export declare const ResponseExtractors: {
 /**
  * Get the default pagination options for a client
  */
-export declare function getDefaultPaginationOptions(client: CoinbasePrimeClient, options: CoinbaseCallOptions | undefined): CoinbaseCallOptions;
-export declare function getQueryParams(client: CoinbasePrimeClient, request: BasePaginatedRequest): Record<string, string | number | string[]>;
+export declare function getDefaultPaginationOptions(client: IPrimeApiClient, options: CoinbaseCallOptions | undefined): CoinbaseCallOptions;
+export declare function getQueryParams(client: IPrimeApiClient, request: BasePaginatedRequest): Record<string, string | number | string[]>;

package/dist/types/shared/serviceContext.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 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.
+ */
+/**
+ * Service context for enhanced enum field detection
+ */
+/**
+ * Service-specific enum mappings to resolve ambiguous field names
+ */
+export interface ServiceEnumContext {
+    serviceName: string;
+    fieldMappings: Record<string, string>;
+    description?: string;
+}
+/**
+ * Registry of service contexts for accurate enum detection
+ */
+export declare const SERVICE_CONTEXTS: Record<string, ServiceEnumContext>;
+/**
+ * Get service context by service name
+ */
+export declare function getServiceContext(serviceName: string): ServiceEnumContext | null;
+/**
+ * Resolve field to enum using service context
+ */
+export declare function resolveFieldWithServiceContext(fieldName: string, serviceName?: string): string | null;
+/**
+ * Get all available service contexts
+ */
+export declare function getAllServiceContexts(): Record<string, ServiceEnumContext>;
+/**
+ * Check if a service has context defined
+ */
+export declare function hasServiceContext(serviceName: string): boolean;

package/dist/types/staking/index.d.ts

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { CoinbaseCallOptions } from '@coinbase-sample/core-ts';
-import { CoinbasePrimeClient } from '../client';
+import { IPrimeApiClient, CoinbaseCallOptions } from '../clients';
 import { CreateStakeRequest, CreateStakeResponse, CreateUnstakeRequest, CreateUnstakeResponse, CreatePortfolioStakeRequest, CreatePortfolioStakeResponse, CreatePortfolioUnstakeRequest, CreatePortfolioUnstakeResponse } from './types';
 export interface IStakingService {
     createStake(request: CreateStakeRequest, options?: CoinbaseCallOptions): Promise<CreateStakeResponse>;
@@ -24,7 +23,7 @@ export interface IStakingService {
 }
 export declare class StakingService implements IStakingService {
     private client;
-    constructor(client: CoinbasePrimeClient);
+    constructor(client: IPrimeApiClient);
     createStake(request: CreateStakeRequest, options?: CoinbaseCallOptions): Promise<CreateStakeResponse>;
     createUnstake(request: CreateUnstakeRequest, options?: CoinbaseCallOptions): Promise<CreateUnstakeResponse>;
     createPortfolioStake(request: CreatePortfolioStakeRequest, options?: CoinbaseCallOptions): Promise<CreatePortfolioStakeResponse>;

package/dist/types/transactions/index.d.ts

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { CoinbaseCallOptions } from '@coinbase-sample/core-ts';
-import { CoinbasePrimeClient } from '../client';
+import { IPrimeApiClient, CoinbaseCallOptions } from '../clients';
 import { CreateConversionRequest, CreateConversionResponse, CreateOnchainTransactionRequest, CreateOnchainTransactionResponse, CreateTransferRequest, CreateTransferResponse, CreateWithdrawalRequest, CreateWithdrawalResponse, GetTransactionRequest, GetTransactionResponse, ListPortfolioTransactionsRequest, ListPortfolioTransactionsResponse, ListWalletTransactionsRequest, ListWalletTransactionsResponse } from './types';
 export interface ITransactionsService {
     getTransaction(request: GetTransactionRequest, options?: CoinbaseCallOptions): Promise<GetTransactionResponse>;
@@ -27,7 +26,7 @@ export interface ITransactionsService {
 }
 export declare class TransactionsService implements ITransactionsService {
     private client;
-    constructor(client: CoinbasePrimeClient);
+    constructor(client: IPrimeApiClient);
     getTransaction(request: GetTransactionRequest, options?: CoinbaseCallOptions): Promise<GetTransactionResponse>;
     listPortfolioTransactions(request: ListPortfolioTransactionsRequest, options?: CoinbaseCallOptions): Promise<ListPortfolioTransactionsResponse>;
     listWalletTransactions(request: ListWalletTransactionsRequest, options?: CoinbaseCallOptions): Promise<ListWalletTransactionsResponse>;

package/dist/types/types.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+export type * from './model/';
+export * from './model/enums/';
+export type { IActivitiesService } from './activities';
+export type { IAddressBooksService } from './addressBooks';
+export type { IAllocationService } from './allocations';
+export type { IAssetsService } from './assets';
+export type { IBalancesService } from './balances';
+export type { ICommissionService } from './commission';
+export type { IFinancingService } from './financing';
+export type { IFuturesService } from './futures';
+export type { IInvoicesService } from './invoices';
+export type { OnchainAddressBookService } from './onchainAddressBook';
+export type { IOrdersService } from './orders';
+export type { IPaymentMethodsService } from './paymentMethods';
+export type { IPortfoliosService } from './portfolios';
+export type { IPositionsService } from './positions';
+export type { IProductsService } from './products';
+export type { IStakingService } from './staking';
+export type { ITransactionsService } from './transactions';
+export type { IUsersService } from './users';
+export type { IWalletsService } from './wallets';
+export { IPrimeApiClient, CoinbasePrimeClientConfig, CoinbaseClient, CoinbaseHttpClientRetryOptions, CoinbaseCallOptions, Method, CoinbaseClientException, CoinbaseError, CoinbaseResponse, TransformRequestFn, TransformResponseFn, } from './clients';

package/dist/types/users/index.d.ts

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { CoinbaseCallOptions } from '@coinbase-sample/core-ts';
-import { CoinbasePrimeClient } from '../client';
+import { IPrimeApiClient, CoinbaseCallOptions } from '../clients';
 import { ListPortfolioUsersRequest, ListPortfolioUsersResponse, ListUsersRequest, ListUsersResponse } from './types';
 export interface IUsersService {
     listUsers(request: ListUsersRequest, options?: CoinbaseCallOptions): Promise<ListUsersResponse>;
@@ -22,7 +21,7 @@ export interface IUsersService {
 }
 export declare class UsersService implements IUsersService {
     private client;
-    constructor(client: CoinbasePrimeClient);
+    constructor(client: IPrimeApiClient);
     listUsers(request: ListUsersRequest, options?: CoinbaseCallOptions): Promise<ListUsersResponse>;
     listPortfolioUsers(request: ListPortfolioUsersRequest, options?: CoinbaseCallOptions): Promise<ListPortfolioUsersResponse>;
 }

package/dist/types/wallets/index.d.ts

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { CoinbaseCallOptions } from '@coinbase-sample/core-ts';
-import { CoinbasePrimeClient } from '../client';
+import { IPrimeApiClient, CoinbaseCallOptions } from '../clients';
 import { ListWalletsRequest, ListWalletsResponse, GetWalletRequest, GetWalletResponse, GetWalletDepositInstructionsRequest, GetWalletDepositInstructionsResponse, ListWalletAddressesRequest, ListWalletAddressesResponse, CreateWalletRequest, CreateWalletResponse, CreateWalletDepositAddressRequest, CreateWalletDepositAddressResponse } from './types';
 export interface IWalletsService {
     listWallets(request: ListWalletsRequest, options?: CoinbaseCallOptions): Promise<ListWalletsResponse>;
@@ -26,7 +25,7 @@ export interface IWalletsService {
 }
 export declare class WalletsService implements IWalletsService {
     private client;
-    constructor(client: CoinbasePrimeClient);
+    constructor(client: IPrimeApiClient);
     listWallets(request: ListWalletsRequest, options?: CoinbaseCallOptions): Promise<ListWalletsResponse>;
     getWallet(request: GetWalletRequest, options?: CoinbaseCallOptions): Promise<GetWalletResponse>;
     getWalletDepositInstructions(request: GetWalletDepositInstructionsRequest, options?: CoinbaseCallOptions): Promise<GetWalletDepositInstructionsResponse>;