@coinbase/cdp-api-client 0.0.42 → 0.0.44

package/dist/types/index.d.ts

@@ -53,39 +53,25 @@ export declare const AbiStateMutability: {
 };
 
 export declare interface Account {
-    id: string;
-    name: string;
-    currency: string;
+    accountId: AccountId;
     type: AccountType;
-    availableBalance: AccountAvailableBalance;
-    hold: AccountHold;
+    owner: Owner;
+    name?: string;
+    projectIds?: ProjectId[];
     createdAt: string;
     updatedAt: string;
 }
 
-export declare type AccountAvailableBalance = {
-    value: string;
-    currency: string;
-};
-
-export declare type AccountHold = {
-    value: string;
-    currency: string;
-};
+export declare type AccountId = string;
 
 export declare interface AccountSource {
-    type: AccountSourceType;
     accountId: string;
+    currency: string;
 }
 
-export declare type AccountSourceType = (typeof AccountSourceType)[keyof typeof AccountSourceType];
-
-export declare const AccountSourceType: {
-    readonly account: "account";
-};
-
 export declare interface AccountTarget {
     accountId: string;
+    currency: string;
 }
 
 export declare interface AccountTokenAddressesResponse {
@@ -97,8 +83,9 @@ export declare interface AccountTokenAddressesResponse {
 export declare type AccountType = (typeof AccountType)[keyof typeof AccountType];
 
 export declare const AccountType: {
-    readonly crypto: "crypto";
-    readonly fiat: "fiat";
+    readonly prime: "prime";
+    readonly business: "business";
+    readonly cdp: "cdp";
 };
 
 export declare interface AchDetails {
@@ -160,7 +147,23 @@ export declare class APIError extends Error {
 
 export declare type APIErrorType = ErrorType | HttpErrorType;
 
-export declare type AuthenticationMethod = EmailAuthentication | SmsAuthentication | DeveloperJWTAuthentication;
+export declare interface Asset {
+    assetId: AssetId;
+    assetType: AssetType;
+    name: string;
+    decimals: number;
+}
+
+export declare type AssetId = string;
+
+export declare type AssetType = (typeof AssetType)[keyof typeof AssetType];
+
+export declare const AssetType: {
+    readonly fiat: "fiat";
+    readonly crypto: "crypto";
+};
+
+export declare type AuthenticationMethod = EmailAuthentication | SmsAuthentication | DeveloperJWTAuthentication | OAuth2Authentication;
 
 export declare type AuthenticationMethods = AuthenticationMethod[];
 
@@ -176,6 +179,52 @@ export declare interface AuthManager {
 
 export declare type BadGatewayErrorResponse = Error_2;
 
+export declare interface Balance {
+    asset: Asset;
+    availableAmount: string;
+    totalAmount: string;
+}
+
+export declare interface Balances {
+    balances: Balance[];
+}
+
+export declare interface Business {
+    selfOwned?: boolean;
+    businessLegalName?: string;
+}
+
+export declare interface CapabilitiesMap {
+    guestCheckout?: CapabilityStatus;
+    sendFiat?: CapabilityStatus;
+    receiveFiat?: CapabilityStatus;
+    sendCrypto?: CapabilityStatus;
+    receiveCrypto?: CapabilityStatus;
+    trade?: CapabilityStatus;
+}
+
+export declare interface CapabilitiesMapRequest {
+    guestCheckout?: CapabilityRequested;
+    sendFiat?: CapabilityRequested;
+    receiveFiat?: CapabilityRequested;
+    sendCrypto?: CapabilityRequested;
+    receiveCrypto?: CapabilityRequested;
+    trade?: CapabilityRequested;
+}
+
+export declare interface CapabilityRequested {
+    requested: boolean;
+}
+
+export declare type CapabilityStatus = (typeof CapabilityStatus)[keyof typeof CapabilityStatus];
+
+export declare const CapabilityStatus: {
+    readonly enabled: "enabled";
+    readonly restricted: "restricted";
+    readonly disabled: "disabled";
+    readonly pending: "pending";
+};
+
 declare const cdpApiClient: <T>(config: AxiosRequestConfig, idempotencyKey?: string) => Promise<T>;
 
 export declare type CdpOptions = {
@@ -225,10 +274,10 @@ export declare type CommonSwapResponseIssuesBalance = {
 export declare const configureCdpApiClient: (options: CdpOptions) => void;
 
 export declare interface CoolPaymentMethod {
-    id?: string;
-    type?: CoolPaymentMethodType;
+    id: string;
+    type: CoolPaymentMethodType;
+    currency: string;
     name?: string;
-    currency?: string;
     verified?: boolean;
     allowDeposit?: boolean;
     allowWithdraw?: boolean;
@@ -243,6 +292,20 @@ export declare const CoolPaymentMethodType: {
     readonly fedwire: "fedwire";
 };
 
+export declare interface CreateAccountRequest {
+    type: CreateAccountRequestType;
+    owner: string;
+    name?: string;
+    projectIds?: ProjectId[];
+}
+
+export declare type CreateAccountRequestType = (typeof CreateAccountRequestType)[keyof typeof CreateAccountRequestType];
+
+export declare const CreateAccountRequestType: {
+    readonly entity: "entity";
+    readonly customer: "customer";
+};
+
 export declare const createEndUserEvmAccount: (projectId: string, userId: string, createEndUserEvmAccountBody: CreateEndUserEvmAccountBody, options?: SecondParameter<typeof cdpApiClient>) => Promise<EndUser>;
 
 export declare type CreateEndUserEvmAccountBody = {
@@ -342,7 +405,7 @@ export declare interface CreateTransferQuote {
     amountType?: CreateTransferQuoteAmountType;
     source: Source;
     target: Target;
-    note?: string;
+    metadata?: Metadata;
 }
 
 export declare type CreateTransferQuoteAmountType = (typeof CreateTransferQuoteAmountType)[keyof typeof CreateTransferQuoteAmountType];
@@ -371,6 +434,68 @@ export declare type CryptoRailNetworksItem = {
     contractAddress?: string;
 };
 
+export declare type Customer = CustomerAllOf & CustomerBase & CustomerAllOfTwo & Required<Pick<CustomerAllOf & CustomerBase & CustomerAllOfTwo, "capabilities" | "requirement" | "type">>;
+
+export declare type CustomerAllOf = {
+    customerId: CustomerId;
+};
+
+export declare type CustomerAllOfTwo = {
+    type?: CustomerType;
+    capabilities?: CapabilitiesMap;
+    readonly requirement?: CustomerAllOfTwoRequirement;
+};
+
+export declare type CustomerAllOfTwoRequirement = Requirement & CustomerAllOfTwoRequirementAllOf;
+
+export declare type CustomerAllOfTwoRequirementAllOf = {
+    [key: string]: unknown;
+};
+
+export declare type CustomerBase = (CustomerBaseOneOf & {
+    projectIds?: ProjectId[];
+}) | (CustomerBaseOneOfTwo & {
+    projectIds?: ProjectId[];
+});
+
+export declare type CustomerBaseOneOf = {
+    individual: Individual;
+};
+
+export declare type CustomerBaseOneOfTwo = {
+    business: Business;
+};
+
+export declare type CustomerCreateRequest = CustomerCreateRequestAllOf & CustomerBase;
+
+export declare type CustomerCreateRequestAllOf = {
+    customerId: CustomerId;
+    type: CustomerType;
+    capabilities?: CapabilitiesMapRequest;
+};
+
+export declare type CustomerId = string;
+
+export declare type CustomerType = (typeof CustomerType)[keyof typeof CustomerType];
+
+export declare const CustomerType: {
+    readonly individual: "individual";
+    readonly business: "business";
+};
+
+export declare type CustomerUpdateRequest = CustomerUpdateRequestAllOf & CustomerBase;
+
+export declare type CustomerUpdateRequestAllOf = {
+    customerId: CustomerId;
+    capabilities?: CapabilitiesMapRequest;
+};
+
+export declare interface DateOfBirth {
+    day?: string;
+    month?: string;
+    year?: string;
+}
+
 export declare interface DeveloperJWTAuthentication {
     type: DeveloperJWTAuthenticationType;
     kid: string;
@@ -383,6 +508,12 @@ export declare const DeveloperJWTAuthenticationType: {
     readonly jwt: "jwt";
 };
 
+declare interface Document_2 {
+    frontFileId: FileId;
+    backFileId: FileId;
+}
+export { Document_2 as Document }
+
 export declare interface EIP712Domain {
     name?: string;
     version?: string;
@@ -431,6 +562,34 @@ export declare interface EndUser {
     createdAt: string;
 }
 
+export declare interface Entity {
+    entityId: EntityId;
+    name: string;
+    productionEntityId?: string;
+    legalEntityId?: string | null;
+    status: EntityStatus;
+    type?: string;
+    capabilities: CapabilitiesMap;
+    createdAt: string;
+    otherInfo?: EntityOtherInfo;
+}
+
+export declare type EntityId = string;
+
+export declare type EntityOtherInfo = {
+    [key: string]: unknown;
+};
+
+export declare type EntityStatus = (typeof EntityStatus)[keyof typeof EntityStatus];
+
+export declare const EntityStatus: {
+    readonly active_without_kyb: "active_without_kyb";
+    readonly pending_kyb: "pending_kyb";
+    readonly documents_required: "documents_required";
+    readonly in_review: "in_review";
+    readonly active: "active";
+};
+
 declare interface Error_2 {
     errorType: ErrorType;
     errorMessage: string;
@@ -527,6 +686,7 @@ export declare interface EvmCall {
     to: string;
     value: string;
     data: string;
+    overrideGasLimit?: string;
 }
 
 export declare interface EvmDataCondition {
@@ -730,6 +890,12 @@ export declare const EvmUserOperationStatus: {
     readonly failed: "failed";
 };
 
+export declare interface ExchangeRate {
+    sourceCurrency: string;
+    targetCurrency: string;
+    rate: string;
+}
+
 export declare const exportEndUserEvmAccount: (projectId: string, userId: string, exportEndUserEvmAccountBody: ExportEndUserEvmAccountBody, options?: SecondParameter<typeof cdpApiClient>) => Promise<ExportEndUserEvmAccount200>;
 
 export declare type ExportEndUserEvmAccount200 = {
@@ -793,6 +959,10 @@ export declare const FeeType: {
     readonly network_fee: "network_fee";
 };
 
+export declare type FileId = string;
+
+export declare type ForbiddenErrorResponse = Error_2;
+
 export declare type FromAmount = string;
 
 export declare type FromToken = string;
@@ -805,10 +975,11 @@ export declare interface FundTransfer {
     sourceAmount: SourceAmount;
     targetAmount: TargetAmount;
     fees: FeeDetails[];
+    exchangeRate?: ExchangeRate;
     sourceDepositInstructions?: SourceDepositInstructions;
     createdAt: string;
     updatedAt: string;
-    note?: string;
+    metadata?: Metadata;
 }
 
 export declare type GasPrice = string;
@@ -882,11 +1053,77 @@ export declare type IdlTypesItem = {
     [key: string]: unknown;
 };
 
+export declare interface Individual {
+    fullName?: string;
+    email?: string;
+    phone?: string;
+    address?: PhysicalAddress;
+    dateOfBirth?: DateOfBirth;
+    sourceOfFunds?: IndividualSourceOfFunds;
+    industry?: IndividualIndustry;
+    cryptoActivity?: IndividualCryptoActivity;
+    connectionToPolitician?: IndividualConnectionToPolitician;
+    taxResidency?: string;
+    taxNumber?: string;
+    nationalities?: string[];
+    verification?: IndividualVerification;
+}
+
+export declare type IndividualConnectionToPolitician = (typeof IndividualConnectionToPolitician)[keyof typeof IndividualConnectionToPolitician];
+
+export declare const IndividualConnectionToPolitician: {
+    readonly none: "none";
+    readonly self_pep: "self_pep";
+    readonly family_of_pep: "family_of_pep";
+    readonly associate_of_pep: "associate_of_pep";
+    readonly unknown: "unknown";
+};
+
+export declare type IndividualCryptoActivity = (typeof IndividualCryptoActivity)[keyof typeof IndividualCryptoActivity];
+
+export declare const IndividualCryptoActivity: {
+    readonly trading: "trading";
+    readonly mining: "mining";
+    readonly other: "other";
+};
+
+export declare type IndividualIndustry = (typeof IndividualIndustry)[keyof typeof IndividualIndustry];
+
+export declare const IndividualIndustry: {
+    readonly finance: "finance";
+    readonly technology: "technology";
+    readonly other: "other";
+};
+
+export declare type IndividualSourceOfFunds = (typeof IndividualSourceOfFunds)[keyof typeof IndividualSourceOfFunds];
+
+export declare const IndividualSourceOfFunds: {
+    readonly employment_income: "employment_income";
+    readonly other: "other";
+};
+
+export declare type IndividualVerification = {
+    document?: IndividualVerificationDocument;
+    additionalDocument?: IndividualVerificationAdditionalDocument;
+};
+
+export declare type IndividualVerificationAdditionalDocument = (Document_2 & IndividualVerificationAdditionalDocumentAllOf) | null;
+
+export declare type IndividualVerificationAdditionalDocumentAllOf = {
+    [key: string]: unknown;
+};
+
+export declare type IndividualVerificationDocument = Document_2 & IndividualVerificationDocumentAllOf;
+
+export declare type IndividualVerificationDocumentAllOf = {
+    [key: string]: unknown;
+};
+
 export declare const initiateAuthentication: (projectId: string, initiateAuthenticationRequest: InitiateAuthenticationRequest, options?: SecondParameter<typeof cdpApiClient>) => Promise<InitiateAuthenticationResponseWrapper>;
 
-export declare type InitiateAuthenticationRequest = InitiateEmailAuthenticationRequest | InitiateSmsAuthenticationRequest;
+export declare type InitiateAuthenticationRequest = InitiateEmailAuthenticationRequest | InitiateSmsAuthenticationRequest | InitiateOAuthAuthenticationRequest;
 
-export declare type InitiateAuthenticationResponseWrapper = InitiateEmailAuthenticationResponse | InitiateSmsAuthenticationResponse;
+export declare type InitiateAuthenticationResponseWrapper = InitiateEmailAuthenticationResponse | InitiateSmsAuthenticationResponse | InitiateOAuthAuthenticationResponse;
 
 export declare type InitiateAuthenticationResult = NonNullable<Awaited<ReturnType<typeof initiateAuthentication>>>;
 
@@ -918,6 +1155,16 @@ export declare interface InitiateEmailAuthenticationResponse {
     nextStep: InitiateEmailAuthenticationNextStep;
 }
 
+export declare interface InitiateOAuthAuthenticationRequest {
+    type: OAuth2ProviderType;
+    redirectUrl: string;
+}
+
+export declare interface InitiateOAuthAuthenticationResponse {
+    flowId: string;
+    authUrl: string;
+}
+
 export declare interface InitiateSmsAuthenticationNextStep {
     type: InitiateSmsAuthenticationNextStepType;
     url: string;
@@ -950,6 +1197,31 @@ export declare type InternalServerErrorResponse = Error_2;
 
 export declare type InvalidSQLQueryErrorResponse = Error_2;
 
+export declare interface Invitation {
+    inviteId: InvitationId;
+    entityId: EntityId;
+    email: string;
+    role: Role;
+    status: InvitationStatus;
+    invitedAt: string;
+    invitedByMemberId: TeamMemberId;
+    acceptedAt?: string | null;
+    rejectedAt?: string | null;
+    expiresAt: string;
+}
+
+export declare type InvitationId = string;
+
+export declare type InvitationStatus = (typeof InvitationStatus)[keyof typeof InvitationStatus];
+
+export declare const InvitationStatus: {
+    readonly pending: "pending";
+    readonly accepted: "accepted";
+    readonly rejected: "rejected";
+    readonly canceled: "canceled";
+    readonly expired: "expired";
+};
+
 export declare function isOpenAPIError(obj: unknown): obj is Error_2;
 
 export declare type KnownAbiType = (typeof KnownAbiType)[keyof typeof KnownAbiType];
@@ -986,27 +1258,24 @@ export declare const LimitPeriod: {
     readonly biweekly: "biweekly";
 };
 
-export declare const listEndUsers: (params?: ListEndUsersParams, options?: SecondParameter<typeof cdpApiClient>) => Promise<ListEndUsers200>;
-
-export declare type ListEndUsers200 = ListEndUsers200AllOf & ListResponse;
+export declare interface LinkableEntity {
+    entityId: EntityId;
+    name: string;
+    type: LinkableEntityType;
+}
 
-export declare type ListEndUsers200AllOf = {
-    endUsers: EndUser[];
-};
+export declare type LinkableEntityType = (typeof LinkableEntityType)[keyof typeof LinkableEntityType];
 
-export declare type ListEndUsersParams = {
-    pageSize?: number;
-    pageToken?: string;
-    sort?: ListEndUsersSortItem[];
+export declare const LinkableEntityType: {
+    readonly business: "business";
+    readonly prime: "prime";
 };
 
-export declare type ListEndUsersResult = NonNullable<Awaited<ReturnType<typeof listEndUsers>>>;
-
-export declare type ListEndUsersSortItem = (typeof ListEndUsersSortItem)[keyof typeof ListEndUsersSortItem];
+export declare type LinkAccountType = (typeof LinkAccountType)[keyof typeof LinkAccountType];
 
-export declare const ListEndUsersSortItem: {
-    readonly "createdAt=asc": "createdAt=asc";
-    readonly "createdAt=desc": "createdAt=desc";
+export declare const LinkAccountType: {
+    readonly business: "business";
+    readonly prime: "prime";
 };
 
 export declare type ListEvmTokenBalancesNetwork = (typeof ListEvmTokenBalancesNetwork)[keyof typeof ListEvmTokenBalancesNetwork];
@@ -1043,10 +1312,18 @@ export declare type ListSpendPermissionsWithEndUserAccountParams = {
 
 export declare type ListSpendPermissionsWithEndUserAccountResult = NonNullable<Awaited<ReturnType<typeof listSpendPermissionsWithEndUserAccount>>>;
 
-export declare const logOutEndUser: (projectId: string, options?: SecondParameter<typeof cdpApiClient>) => Promise<void>;
+export declare const logOutEndUser: (projectId: string, logOutEndUserBody?: LogOutEndUserBody, options?: SecondParameter<typeof cdpApiClient>) => Promise<void>;
+
+export declare type LogOutEndUserBody = {
+    refreshToken?: string;
+};
 
 export declare type LogOutEndUserResult = NonNullable<Awaited<ReturnType<typeof logOutEndUser>>>;
 
+export declare interface Metadata {
+    [key: string]: unknown;
+}
+
 export declare interface MintAddressCriterion {
     type: MintAddressCriterionType;
     addresses: string[];
@@ -1106,6 +1383,30 @@ export declare const Network: {
     readonly unichain: "unichain";
 };
 
+export declare interface OAuth2Authentication {
+    type: OAuth2ProviderType;
+    sub: string;
+    email?: string;
+}
+
+export declare type OAuth2ErrorCode = (typeof OAuth2ErrorCode)[keyof typeof OAuth2ErrorCode];
+
+export declare const OAuth2ErrorCode: {
+    readonly access_denied: "access_denied";
+    readonly invalid_request: "invalid_request";
+    readonly invalid_client: "invalid_client";
+    readonly invalid_grant: "invalid_grant";
+    readonly unauthorized_client: "unauthorized_client";
+    readonly unsupported_grant_type: "unsupported_grant_type";
+    readonly invalid_scope: "invalid_scope";
+};
+
+export declare type OAuth2ProviderType = (typeof OAuth2ProviderType)[keyof typeof OAuth2ProviderType];
+
+export declare const OAuth2ProviderType: {
+    readonly google: "google";
+};
+
 export declare interface OnchainAddress {
     address: string;
     network: Network;
@@ -1202,6 +1503,7 @@ export declare interface OnrampOrder {
     txHash?: string;
     createdAt: string;
     updatedAt: string;
+    partnerUserRef?: string;
 }
 
 export declare interface OnrampOrderFee {
@@ -1270,33 +1572,46 @@ export declare interface OnrampSession {
     onrampUrl: string;
 }
 
+export declare type Owner = string;
+
 export declare type PageSizeParameter = number;
 
 export declare type PageTokenParameter = string;
 
-export declare interface PaymentMethod {
+export declare interface PaymentAccount {
     id: string;
-    type: PaymentMethodType;
+    name: string;
     currency: string;
-    actions: PaymentRailAction[];
-    limits?: PaymentMethodLimits;
+    type: PaymentAccountType;
+    availableBalance: PaymentAccountAvailableBalance;
+    hold: PaymentAccountHold;
+    depositInstructions?: SourceDepositInstructions;
+    createdAt: string;
+    updatedAt: string;
 }
 
-export declare type PaymentMethodLimits = {
-    sourceLimit?: PaymentMethodLimitsSourceLimit;
-    targetLimit?: PaymentMethodLimitsTargetLimit;
+export declare type PaymentAccountAvailableBalance = {
+    value: string;
+    currency: string;
 };
 
-export declare type PaymentMethodLimitsSourceLimit = {
-    amount?: string;
-    currency?: string;
+export declare type PaymentAccountHold = {
+    value: string;
+    currency: string;
 };
 
-export declare type PaymentMethodLimitsTargetLimit = {
-    amount?: string;
-    currency?: string;
+export declare type PaymentAccountType = (typeof PaymentAccountType)[keyof typeof PaymentAccountType];
+
+export declare const PaymentAccountType: {
+    readonly crypto: "crypto";
+    readonly fiat: "fiat";
 };
 
+export declare interface PaymentMethod {
+    paymentMethodId: string;
+    assetId: AssetId;
+}
+
 export declare interface PaymentMethodRequest {
     id: string;
 }
@@ -1304,27 +1619,15 @@ export declare interface PaymentMethodRequest {
 export declare type PaymentMethodRequiredErrorResponse = Error_2;
 
 export declare interface PaymentMethodSource {
-    type: PaymentMethodSourceType;
     paymentMethodId: string;
+    currency: string;
 }
 
-export declare type PaymentMethodSourceType = (typeof PaymentMethodSourceType)[keyof typeof PaymentMethodSourceType];
-
-export declare const PaymentMethodSourceType: {
-    readonly payment_method: "payment_method";
-};
-
 export declare interface PaymentMethodTarget {
     paymentMethodId: string;
+    currency: string;
 }
 
-export declare type PaymentMethodType = (typeof PaymentMethodType)[keyof typeof PaymentMethodType];
-
-export declare const PaymentMethodType: {
-    readonly card: "card";
-    readonly fiat_account: "fiat_account";
-};
-
 export declare type PaymentRailAction = (typeof PaymentRailAction)[keyof typeof PaymentRailAction];
 
 export declare const PaymentRailAction: {
@@ -1332,6 +1635,36 @@ export declare const PaymentRailAction: {
     readonly target: "target";
 };
 
+export declare interface PaymentsPaymentMethod {
+    id: string;
+    type: PaymentsPaymentMethodType;
+    currency: string;
+    actions: PaymentRailAction[];
+    limits?: PaymentsPaymentMethodLimits;
+}
+
+export declare type PaymentsPaymentMethodLimits = {
+    sourceLimit?: PaymentsPaymentMethodLimitsSourceLimit;
+    targetLimit?: PaymentsPaymentMethodLimitsTargetLimit;
+};
+
+export declare type PaymentsPaymentMethodLimitsSourceLimit = {
+    amount?: string;
+    currency?: string;
+};
+
+export declare type PaymentsPaymentMethodLimitsTargetLimit = {
+    amount?: string;
+    currency?: string;
+};
+
+export declare type PaymentsPaymentMethodType = (typeof PaymentsPaymentMethodType)[keyof typeof PaymentsPaymentMethodType];
+
+export declare const PaymentsPaymentMethodType: {
+    readonly card: "card";
+    readonly fiat_account: "fiat_account";
+};
+
 export declare type PaymentStatus = (typeof PaymentStatus)[keyof typeof PaymentStatus];
 
 export declare const PaymentStatus: {
@@ -1340,8 +1673,138 @@ export declare const PaymentStatus: {
     readonly in_progress: "in_progress";
     readonly completed: "completed";
     readonly failed: "failed";
+    readonly unknown: "unknown";
+};
+
+export declare interface PaymentsTransfer {
+    id: string;
+    sourceType: PaymentsTransferSourceType;
+    source: PaymentMethodRequest;
+    targetType: PaymentsTransferTargetType;
+    target: CryptoRailAddress;
+    sourceAmount: string;
+    sourceCurrency: string;
+    targetAmount: string;
+    targetCurrency: string;
+    userAmount: string;
+    userCurrency: string;
+    fees: Fee[];
+    status: PaymentsTransferStatus;
+    createdAt: string;
+    updatedAt: string;
+    transactionHash?: string;
+}
+
+export declare type PaymentsTransferSource = PaymentMethodRequest;
+
+export declare type PaymentsTransferSourceType = (typeof PaymentsTransferSourceType)[keyof typeof PaymentsTransferSourceType];
+
+export declare const PaymentsTransferSourceType: {
+    readonly payment_method: "payment_method";
+};
+
+export declare type PaymentsTransferStatus = (typeof PaymentsTransferStatus)[keyof typeof PaymentsTransferStatus];
+
+export declare const PaymentsTransferStatus: {
+    readonly created: "created";
+    readonly pending: "pending";
+    readonly started: "started";
+    readonly completed: "completed";
+    readonly failed: "failed";
+};
+
+export declare type PaymentsTransferTarget = CryptoRailAddress;
+
+export declare type PaymentsTransferTargetType = (typeof PaymentsTransferTargetType)[keyof typeof PaymentsTransferTargetType];
+
+export declare const PaymentsTransferTargetType: {
+    readonly crypto_rail: "crypto_rail";
+};
+
+export declare interface Permission {
+    permissionId: PermissionId;
+    name: string;
+    entityId: EntityId;
+    subjectType: PermissionSubjectType;
+    verb: PermissionVerb;
+    object: string;
+    description?: string;
+    createdAt: string;
+}
+
+export declare interface PermissionCatalog {
+    verbs: PermissionCatalogVerbsItem[];
+    objects: PermissionCatalogObjectsItem[];
+}
+
+export declare type PermissionCatalogObjectsItem = {
+    id?: string;
+    type?: PermissionCatalogObjectsItemType;
+    name?: string;
+    parentId?: string | null;
 };
 
+export declare type PermissionCatalogObjectsItemType = (typeof PermissionCatalogObjectsItemType)[keyof typeof PermissionCatalogObjectsItemType];
+
+export declare const PermissionCatalogObjectsItemType: {
+    readonly entity: "entity";
+    readonly project: "project";
+};
+
+export declare type PermissionCatalogVerbsItem = {
+    name?: string;
+    displayName?: string;
+    description?: string;
+};
+
+export declare type PermissionId = string;
+
+export declare type PermissionSubjectType = (typeof PermissionSubjectType)[keyof typeof PermissionSubjectType];
+
+export declare const PermissionSubjectType: {
+    readonly team_member: "team_member";
+    readonly api_key: "api_key";
+};
+
+export declare type PermissionVerb = (typeof PermissionVerb)[keyof typeof PermissionVerb];
+
+export declare const PermissionVerb: {
+    readonly create_api_key: "create_api_key";
+    readonly read_api_key: "read_api_key";
+    readonly update_api_key: "update_api_key";
+    readonly delete_api_key: "delete_api_key";
+    readonly create_project: "create_project";
+    readonly read_project: "read_project";
+    readonly update_project: "update_project";
+    readonly delete_project: "delete_project";
+    readonly read_entity: "read_entity";
+    readonly update_entity: "update_entity";
+    readonly invite_team_member: "invite_team_member";
+    readonly read_team_member: "read_team_member";
+    readonly update_team_member: "update_team_member";
+    readonly remove_team_member: "remove_team_member";
+    readonly create_role: "create_role";
+    readonly read_role: "read_role";
+    readonly update_role: "update_role";
+    readonly delete_role: "delete_role";
+    readonly create_permission: "create_permission";
+    readonly read_permission: "read_permission";
+    readonly update_permission: "update_permission";
+    readonly delete_permission: "delete_permission";
+    readonly manage_billing: "manage_billing";
+    readonly view_audit_logs: "view_audit_logs";
+    readonly manage_all: "manage_all";
+};
+
+export declare interface PhysicalAddress {
+    line1?: string;
+    line2?: string;
+    city?: string;
+    state?: string;
+    postCode?: string;
+    countryCode?: string;
+}
+
 export declare interface Policy {
     id: string;
     description?: string;
@@ -1400,6 +1863,18 @@ export declare const ProgramIdCriterionType: {
     readonly programId: "programId";
 };
 
+export declare interface Project {
+    projectId: ProjectId;
+    name: string;
+    entityId: EntityId;
+    sandbox?: boolean;
+    createdAt: string;
+    updatedAt?: string | null;
+    deletedAt?: string | null;
+}
+
+export declare type ProjectId = string;
+
 export declare type RateLimitExceededResponse = Error_2;
 
 export declare const refreshAccessToken: (projectId: string, refreshAccessTokenBody: RefreshAccessTokenBody, options?: SecondParameter<typeof cdpApiClient>) => Promise<RefreshAccessToken200>;
@@ -1408,10 +1883,12 @@ export declare type RefreshAccessToken200 = {
     endUser: EndUser;
     accessToken: string;
     validUntil: string;
+    refreshToken?: string;
 };
 
 export declare type RefreshAccessTokenBody = {
     grantType: RefreshAccessTokenBodyGrantType;
+    refreshToken?: string;
 };
 
 export declare type RefreshAccessTokenBodyGrantType = (typeof RefreshAccessTokenBodyGrantType)[keyof typeof RefreshAccessTokenBodyGrantType];
@@ -1443,6 +1920,34 @@ export declare type RegisterTemporaryWalletSecretBody = {
 
 export declare type RegisterTemporaryWalletSecretResult = NonNullable<Awaited<ReturnType<typeof registerTemporaryWalletSecret>>>;
 
+export declare interface Requirement {
+    due?: RequirementDue[];
+    pending?: RequirementDue[];
+    errors?: RequirementError[];
+}
+
+export declare interface RequirementDue {
+    field: RequirementField;
+    deadline?: string;
+}
+
+export declare interface RequirementError {
+    code: RequirementErrorCode;
+    reason: string;
+    requirement: RequirementField;
+}
+
+export declare type RequirementErrorCode = (typeof RequirementErrorCode)[keyof typeof RequirementErrorCode];
+
+export declare const RequirementErrorCode: {
+    readonly information_missing: "information_missing";
+    readonly invalid_address: "invalid_address";
+    readonly verification_document_dob_mismatch: "verification_document_dob_mismatch";
+    readonly verification_document_expired: "verification_document_expired";
+};
+
+export declare type RequirementField = string;
+
 export declare interface RevokeSpendPermissionRequest {
     walletSecretId: string;
     network: SpendPermissionNetwork;
@@ -1455,6 +1960,17 @@ export declare const revokeSpendPermissionWithEndUserAccount: (projectId: string
 
 export declare type RevokeSpendPermissionWithEndUserAccountResult = NonNullable<Awaited<ReturnType<typeof revokeSpendPermissionWithEndUserAccount>>>;
 
+export declare interface Role {
+    roleId: RoleId;
+    name: string;
+    description?: string | null;
+    permissions: Permission[];
+    createdAt: string;
+    updatedAt: string;
+}
+
+export declare type RoleId = string;
+
 export declare type Rule = SignEvmTransactionRule | SendEvmTransactionRule | SignEvmMessageRule | SignEvmTypedDataRule | SignSolTransactionRule | SendSolTransactionRule | SignSolMessageRule | SignEvmHashRule | PrepareUserOperationRule | SendUserOperationRule;
 
 export declare type SecondFactorProofTokenParameter = string;
@@ -2068,13 +2584,6 @@ export declare const SourceDepositInstructionsPaymentMethodType: {
     readonly fedwire: "fedwire";
 };
 
-export declare type SourceType = (typeof SourceType)[keyof typeof SourceType];
-
-export declare const SourceType: {
-    readonly account: "account";
-    readonly payment_method: "payment_method";
-};
-
 export declare interface SpendPermission {
     account: string;
     spender: string;
@@ -2163,6 +2672,18 @@ export declare interface TargetAmount {
     currency: string;
 }
 
+export declare interface TeamMember {
+    memberId: TeamMemberId;
+    userId: string;
+    entityId: EntityId;
+    sandbox?: boolean;
+    email: string;
+    role: Role;
+    kycRequired: boolean;
+}
+
+export declare type TeamMemberId = string;
+
 export declare type TimedOutErrorResponse = Error_2;
 
 export declare interface Token {
@@ -2190,24 +2711,92 @@ export declare interface TokenFee {
 export declare type ToToken = string;
 
 export declare interface Transfer {
-    id: string;
-    sourceType: TransferSourceType;
-    source: PaymentMethodRequest;
-    targetType: TransferTargetType;
-    target: CryptoRailAddress;
-    sourceAmount: string;
-    sourceCurrency: string;
-    targetAmount: string;
-    targetCurrency: string;
-    userAmount: string;
-    userCurrency: string;
-    fees: Fee[];
+    transferId: string;
     status: TransferStatus;
+    source: TransferSource;
+    target: TransferTarget;
+    amount: string;
+    amountAssetId: string;
+    sourceAmount?: string;
+    targetAmount?: string;
+    fees?: TransferFees;
+    completedAt?: string;
+    sourceDepositInstructions?: TransferSourceDepositsInstructions;
+    failureReason?: TransferFailureReason;
+    reversalReason?: TransferReversalReason;
+    cancellationReason?: TransferCancellationReason;
+    lastError?: TransferLastError;
+    expiresAt?: string;
+    executedAt?: string;
     createdAt: string;
     updatedAt: string;
-    transactionHash?: string;
 }
 
+export declare type TransferCancellationReason = (typeof TransferCancellationReason)[keyof typeof TransferCancellationReason];
+
+export declare const TransferCancellationReason: {
+    readonly user_canceled: "user_canceled";
+    readonly system_canceled: "system_canceled";
+    readonly expired: "expired";
+    readonly compliance_canceled: "compliance_canceled";
+    readonly risk_canceled: "risk_canceled";
+    readonly duplicate_canceled: "duplicate_canceled";
+    readonly insufficient_funds_canceled: "insufficient_funds_canceled";
+};
+
+export declare type TransferFailureReason = (typeof TransferFailureReason)[keyof typeof TransferFailureReason];
+
+export declare const TransferFailureReason: {
+    readonly insufficient_funds: "insufficient_funds";
+    readonly invalid_source: "invalid_source";
+    readonly invalid_target: "invalid_target";
+    readonly compliance_failure: "compliance_failure";
+    readonly network_error: "network_error";
+    readonly rate_limit_exceeded: "rate_limit_exceeded";
+    readonly account_restricted: "account_restricted";
+    readonly amount_too_large: "amount_too_large";
+    readonly amount_too_small: "amount_too_small";
+    readonly asset_not_supported: "asset_not_supported";
+    readonly processing_error: "processing_error";
+    readonly network_failure: "network_failure";
+    readonly insufficient_gas: "insufficient_gas";
+    readonly transaction_reverted: "transaction_reverted";
+    readonly timeout: "timeout";
+    readonly compliance_rejection: "compliance_rejection";
+    readonly recipient_unavailable: "recipient_unavailable";
+};
+
+export declare interface TransferFee {
+    name: TransferFeeName;
+    amount: string;
+    assetId: AssetId;
+}
+
+export declare type TransferFeeName = (typeof TransferFeeName)[keyof typeof TransferFeeName];
+
+export declare const TransferFeeName: {
+    readonly network_fee: "network_fee";
+    readonly processing_fee: "processing_fee";
+    readonly wire_fee: "wire_fee";
+    readonly exchange_fee: "exchange_fee";
+    readonly spread_fee: "spread_fee";
+};
+
+export declare type TransferFees = TransferFee[];
+
+export declare type TransferLastError = {
+    code?: string;
+    message?: string;
+    param?: string;
+    details?: TransferLastErrorDetails;
+};
+
+export declare type TransferLastErrorDetails = {
+    availableBalance?: string;
+    requiredAmount?: string;
+    retryAfter?: number;
+};
+
 export declare interface TransferQuote {
     id: string;
     paymentStatus: PaymentStatus;
@@ -2216,39 +2805,78 @@ export declare interface TransferQuote {
     sourceAmount: SourceAmount;
     targetAmount: TargetAmount;
     fees: FeeDetails[];
+    exchangeRate?: ExchangeRate;
     expiresAt: string;
-    note?: string;
+    metadata?: Metadata;
 }
 
 export declare interface TransferQuoteDetails {
     quoteId: string;
 }
 
-export declare type TransferSource = PaymentMethodRequest;
+export declare interface TransferRequest {
+    source: TransferSource;
+    target: TransferTarget;
+    amount: string;
+    amountAssetId: string;
+    execute: boolean;
+}
 
-export declare type TransferSourceType = (typeof TransferSourceType)[keyof typeof TransferSourceType];
+export declare type TransferReversalReason = (typeof TransferReversalReason)[keyof typeof TransferReversalReason];
 
-export declare const TransferSourceType: {
-    readonly payment_method: "payment_method";
+export declare const TransferReversalReason: {
+    readonly user_requested: "user_requested";
+    readonly compliance_reversal: "compliance_reversal";
+    readonly fraud_reversal: "fraud_reversal";
+    readonly network_reversal: "network_reversal";
+    readonly system_reversal: "system_reversal";
+};
+
+export declare interface TransfersAccount {
+    accountId: string;
+    assetId: AssetId;
+}
+
+export declare type TransferSource = TransfersAccount | PaymentMethod;
+
+export declare interface TransferSourceDepositsInstructions {
+    paymentMethodType: TransferSourceDepositsInstructionsPaymentMethodType;
+    assetId: TransferSourceDepositsInstructionsAssetId;
+    accountName: string;
+    accountAddress: string;
+    accountNumber: string;
+    routingNumber: string;
+    bankName: string;
+    bankAddress: string;
+    bankCountryName: string;
+}
+
+export declare type TransferSourceDepositsInstructionsAssetId = (typeof TransferSourceDepositsInstructionsAssetId)[keyof typeof TransferSourceDepositsInstructionsAssetId];
+
+export declare const TransferSourceDepositsInstructionsAssetId: {
+    readonly usd: "usd";
+};
+
+export declare type TransferSourceDepositsInstructionsPaymentMethodType = (typeof TransferSourceDepositsInstructionsPaymentMethodType)[keyof typeof TransferSourceDepositsInstructionsPaymentMethodType];
+
+export declare const TransferSourceDepositsInstructionsPaymentMethodType: {
+    readonly fedwire: "fedwire";
 };
 
 export declare type TransferStatus = (typeof TransferStatus)[keyof typeof TransferStatus];
 
 export declare const TransferStatus: {
-    readonly created: "created";
-    readonly pending: "pending";
-    readonly started: "started";
+    readonly requires_execution: "requires_execution";
+    readonly awaiting_funds: "awaiting_funds";
+    readonly processing: "processing";
     readonly completed: "completed";
     readonly failed: "failed";
+    readonly canceled: "canceled";
+    readonly expired: "expired";
+    readonly reversed: "reversed";
 };
 
-export declare type TransferTarget = CryptoRailAddress;
-
-export declare type TransferTargetType = (typeof TransferTargetType)[keyof typeof TransferTargetType];
-
-export declare const TransferTargetType: {
-    readonly crypto_rail: "crypto_rail";
-};
+export declare type TransferTarget = TransfersAccount | PaymentMethod;
 
 export declare type UnauthorizedErrorResponse = Error_2;
 
@@ -2281,6 +2909,7 @@ export declare type VerifyEmailAuthentication200 = {
     message: string;
     accessToken: string;
     validUntil: string;
+    refreshToken?: string;
 };
 
 export declare interface VerifyEmailAuthenticationRequest {
@@ -2290,6 +2919,24 @@ export declare interface VerifyEmailAuthenticationRequest {
 
 export declare type VerifyEmailAuthenticationResult = NonNullable<Awaited<ReturnType<typeof verifyEmailAuthentication>>>;
 
+export declare const verifyOAuthCode: (projectId: string, providerType: OAuth2ProviderType, verifyOAuthCodeRequest: VerifyOAuthCodeRequest, options?: SecondParameter<typeof cdpApiClient>) => Promise<VerifyOAuthCode200>;
+
+export declare type VerifyOAuthCode200 = {
+    endUser: EndUser;
+    isNewEndUser: boolean;
+    message: string;
+    accessToken: string;
+    validUntil: string;
+    refreshToken?: string;
+};
+
+export declare interface VerifyOAuthCodeRequest {
+    flowId: string;
+    code: string;
+}
+
+export declare type VerifyOAuthCodeResult = NonNullable<Awaited<ReturnType<typeof verifyOAuthCode>>>;
+
 export declare const verifySmsAuthentication: (projectId: string, verifySmsAuthenticationRequest: VerifySmsAuthenticationRequest, options?: SecondParameter<typeof cdpApiClient>) => Promise<VerifySmsAuthentication200>;
 
 export declare type VerifySmsAuthentication200 = {
@@ -2298,6 +2945,7 @@ export declare type VerifySmsAuthentication200 = {
     message: string;
     accessToken: string;
     validUntil: string;
+    refreshToken?: string;
 };
 
 export declare interface VerifySmsAuthenticationRequest {