Merge pull request #1606 from Adyen/sdk-automation/balanceplatform

[balanceplatform] Code generation: update services and models

Author: gcatanese

src/__tests__/balancePlatform.spec.ts

@@ -1444,5 +1444,190 @@ describe("Balance Platform", (): void => {
         });
     });
 
+    describe("SCAAssociationManagementApi", (): void => {
+        it("should support PATCH /scaAssociations", async (): Promise<void> => {
+            scope.patch("/scaAssociations")
+                .reply(200, {
+                    "scaAssociations": [
+                        {
+                            "scaDeviceId": "BSDR42XV3223223S5N6CDQDGH53M8H",
+                            "entityType": "accountHolder",
+                            "entityId": "AH00000000000000000000001",
+                            "status": "active"
+                        }
+                    ]
+                });
+
+            const request: Types.balancePlatform.ApproveAssociationRequest = {
+                "status": Types.balancePlatform.AssociationStatus.Active,
+                "entityType": Types.balancePlatform.ScaEntityType.AccountHolder,
+                "entityId": "AH00000000000000000000001",
+                "scaDeviceIds": [
+                    "BSDR42XV3223223S5N6CDQDGH53M8H"
+                ]
+            };
+
+            const response: Types.balancePlatform.ApproveAssociationResponse = await balancePlatformService.SCAAssociationManagementApi.approveAssociation(request);
+
+            expect(response.scaAssociations).toBeTruthy();
+            expect(response.scaAssociations?.length).toBe(1);
+            expect(response.scaAssociations![0].scaDeviceId).toBe("BSDR42XV3223223S5N6CDQDGH53M8H");
+            expect(response.scaAssociations![0].entityType).toBe("accountHolder");
+            expect(response.scaAssociations![0].entityId).toBe("AH00000000000000000000001");
+            expect(response.scaAssociations![0].status).toBe("active");
+        });
+
+        it("should support GET /scaAssociations", async (): Promise<void> => {
+            const entityType = Types.balancePlatform.ScaEntityType.AccountHolder;
+            const entityId = "AH3227J223222D5HHM4779X6X";
+            const pageSize = 10;
+            const pageNumber = 0;
+
+            scope.get(`/scaAssociations?entityType=${entityType}&entityId=${entityId}&pageSize=${pageSize}`)
+                .reply(200, {
+                    "_links": {
+                        "self": {
+                            "href": `https://exampledomain.com/bcl/api/v2/scaAssociations?pageNumber=${pageNumber}&entityType=${entityType}&pageSize=${pageSize}&entityId=${entityId}`
+                        }
+                    },
+                    "itemsTotal": 2,
+                    "pagesTotal": 1,
+                    "data": [
+                        {
+                            "scaDeviceId": "BSDR11111111111A1AAA1AAAAA1AA1",
+                            "scaDeviceName": "Device 1",
+                            "scaDeviceType": "ios",
+                            "entityType": "accountHolder",
+                            "entityId": "AH00000000000000000000001",
+                            "status": "active",
+                            "createdAt": "2025-09-02T14:39:17.232Z"
+                        },
+                        {
+                            "scaDeviceId": "BSDR22222222222B2BBB2BBBBB2BB2",
+                            "scaDeviceName": "Device 2",
+                            "scaDeviceType": "ios",
+                            "entityType": "accountHolder",
+                            "entityId": "AH00000000000000000000001",
+                            "status": "pendingApproval",
+                            "createdAt": "2025-09-02T14:39:17.232Z"
+                        }
+                    ]
+                });
+
+            const response: Types.balancePlatform.ListAssociationsResponse = await balancePlatformService.SCAAssociationManagementApi.listAssociations(entityType, entityId, pageSize, pageNumber);
+
+            expect(response).toBeTruthy();
+            expect(response.itemsTotal).toBe(2);
+            expect(response.pagesTotal).toBe(1);
+            expect(response.data).toBeTruthy();
+            expect(response.data?.length).toBe(2);
+            expect(response.data![0].scaDeviceId).toBe("BSDR11111111111A1AAA1AAAAA1AA1");
+            expect(response.data![0].scaDeviceName).toBe("Device 1");
+            expect(response.data![0].status).toBe("active");
+            expect(response.data![1].scaDeviceId).toBe("BSDR22222222222B2BBB2BBBBB2BB2");
+            expect(response.data![1].status).toBe("pendingApproval");
+        });
+
+        it("should support DELETE /scaAssociations", async (): Promise<void> => {
+            scope.delete("/scaAssociations")
+                .reply(204);
+
+            const request: Types.balancePlatform.RemoveAssociationRequest = {
+                "entityType": Types.balancePlatform.ScaEntityType.AccountHolder,
+                "entityId": "AH00000000000000000000001",
+                "scaDeviceIds": ["BSDR11111111111A1AAA1AAAAA1AA1"]
+            };
+
+            await balancePlatformService.SCAAssociationManagementApi.removeAssociation(request);
+
+            expect(scope.isDone()).toBeTruthy();
+        });
+    });
+
+    describe("SCADeviceManagementApi", (): void => {
+        it("should support POST /scaDevices", async (): Promise<void> => {
+            scope.post("/scaDevices")
+                .reply(200, {
+                    "scaDevice": {
+                        "id": "BSDR42XV3223223S5N6CDQDGH53M8H",
+                        "name": "My Device",
+                        "type": "ios"
+                    },
+                    "sdkInput": "eyJjaGFsbGVuZ2UiOiJVWEZaTURONGNXWjZUVFExUlhWV2JuaEJPVzVzTm05cVVEUktUbFZtZGtrPSJ9"
+                });
+
+            const request: Types.balancePlatform.BeginScaDeviceRegistrationRequest = {
+                "name": "My Device",
+                "sdkOutput": "eyJjaGFsbGVuZ2UiOiJVWEZaTURONGNXWjZUVFExUlhWV2JuaEJPVzVzTm05cVVEUktUbFZtZGtrPSJ9"
+            };
+
+            const response: Types.balancePlatform.BeginScaDeviceRegistrationResponse = await balancePlatformService.SCADeviceManagementApi.beginScaDeviceRegistration(request);
+
+            expect(response).toBeTruthy();
+            expect(response.scaDevice).toBeTruthy();
+            expect(response.scaDevice?.id).toBe("BSDR42XV3223223S5N6CDQDGH53M8H");
+            expect(response.scaDevice?.name).toBe("My Device");
+            expect(response.scaDevice?.type).toBe("ios");
+            expect(response.sdkInput).toBe("eyJjaGFsbGVuZ2UiOiJVWEZaTURONGNXWjZUVFExUlhWV2JuaEJPVzVzTm05cVVEUktUbFZtZGtrPSJ9");
+        });
+
+        it("should support PATCH /scaDevices/{deviceId}", async (): Promise<void> => {
+            const deviceId = "BSDR42XV3223223S5N6CDQDGH53M8H";
+            scope.patch(`/scaDevices/${deviceId}`)
+                .reply(200, {
+                    "scaDevice": {
+                        "id": "BSDR42XV3223223S5N6CDQDGH53M8H",
+                        "name": "Device",
+                        "type": "ios"
+                    }
+                });
+
+            const request: Types.balancePlatform.FinishScaDeviceRegistrationRequest = {
+                "sdkOutput": "eyJjaGFsbGVuZ2UiOiJVWEZaTURONGNXWjZUVFExUlhWV2JuaEJPVzVzTm05cVVEUktUbFZtZGtrPSJ9"
+            };
+
+            const response: Types.balancePlatform.FinishScaDeviceRegistrationResponse = await balancePlatformService.SCADeviceManagementApi.finishScaDeviceRegistration(deviceId, request);
+
+            expect(response).toBeTruthy();
+            expect(response.scaDevice).toBeTruthy();
+            expect(response.scaDevice?.id).toBe("BSDR42XV3223223S5N6CDQDGH53M8H");
+            expect(response.scaDevice?.name).toBe("Device");
+            expect(response.scaDevice?.type).toBe("ios");
+        });
+
+        it("should support POST /scaDevices/{deviceId}/scaAssociations", async (): Promise<void> => {
+            const deviceId = "BSDR42XV3223223S5N6CDQDGH53M8H";
+            scope.post(`/scaDevices/${deviceId}/scaAssociations`)
+                .reply(200, {
+                    "scaAssociations": [
+                        {
+                            "scaDeviceId": "BSDR11111111111A1AAA1AAAAA1AA1",
+                            "entityType": "accountHolder",
+                            "entityId": "AH00000000000000000000001",
+                            "status": "pendingApproval"
+                        }
+                    ]
+                });
+
+            const request: Types.balancePlatform.SubmitScaAssociationRequest = {
+                "entities": [
+                    {
+                        "type": Types.balancePlatform.ScaEntityType.AccountHolder,
+                        "id": "AH00000000000000000000001"
+                    }
+                ]
+            };
+
+            const response: Types.balancePlatform.SubmitScaAssociationResponse = await balancePlatformService.SCADeviceManagementApi.submitScaAssociation(deviceId, request);
+
+            expect(response).toBeTruthy();
+            expect(response.scaAssociations).toBeTruthy();
+            expect(response.scaAssociations?.length).toBe(1);
+            expect(response.scaAssociations![0].scaDeviceId).toBe("BSDR11111111111A1AAA1AAAAA1AA1");
+            expect(response.scaAssociations![0].entityType).toBe("accountHolder");
+            expect(response.scaAssociations![0].entityId).toBe("AH00000000000000000000001");
+            expect(response.scaAssociations![0].status).toBe("pendingApproval");
+        });
+    });
 
 });

src/services/balancePlatform/index.ts

@@ -21,6 +21,8 @@ import { NetworkTokensApi } from "./networkTokensApi";
 import { PaymentInstrumentGroupsApi } from "./paymentInstrumentGroupsApi";
 import { PaymentInstrumentsApi } from "./paymentInstrumentsApi";
 import { PlatformApi } from "./platformApi";
+import { SCAAssociationManagementApi } from "./sCAAssociationManagementApi";
+import { SCADeviceManagementApi } from "./sCADeviceManagementApi";
 import { TransactionRulesApi } from "./transactionRulesApi";
 import { TransferLimitsBalanceAccountLevelApi } from "./transferLimitsBalanceAccountLevelApi";
 import { TransferLimitsBalancePlatformLevelApi } from "./transferLimitsBalancePlatformLevelApi";
@@ -91,6 +93,14 @@ export default class BalancePlatformAPI extends Service {
         return new PlatformApi(this.client);
     }
 
+    public get SCAAssociationManagementApi() {
+        return new SCAAssociationManagementApi(this.client);
+    }
+
+    public get SCADeviceManagementApi() {
+        return new SCADeviceManagementApi(this.client);
+    }
+
     public get TransactionRulesApi() {
         return new TransactionRulesApi(this.client);
     }

src/services/balancePlatform/sCAAssociationManagementApi.ts

@@ -0,0 +1,106 @@
+/*
+ * The version of the OpenAPI document: v2
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit this class manually.
+ */
+
+
+import getJsonResponse from "../../helpers/getJsonResponse";
+import Service from "../../service";
+import Client from "../../client";
+import { IRequest } from "../../typings/requestOptions";
+import Resource from "../resource";
+
+import { ObjectSerializer } from "../../typings/balancePlatform/objectSerializer";
+import { ApproveAssociationRequest } from "../../typings/balancePlatform/models";
+import { ApproveAssociationResponse } from "../../typings/balancePlatform/models";
+import { ListAssociationsResponse } from "../../typings/balancePlatform/models";
+import { RemoveAssociationRequest } from "../../typings/balancePlatform/models";
+import { ScaEntityType } from "../../typings/balancePlatform/models";
+
+/**
+ * API handler for SCAAssociationManagementApi
+ */
+export class SCAAssociationManagementApi extends Service {
+
+    private readonly API_BASEPATH: string = "https://balanceplatform-api-test.adyen.com/bcl/v2";
+    private baseUrl: string;
+
+    public constructor(client: Client){
+        super(client);
+        this.baseUrl = this.createBaseUrl(this.API_BASEPATH);
+    }
+
+    /**
+    * @summary Approve a pending approval association
+    * @param approveAssociationRequest {@link ApproveAssociationRequest } 
+    * @param requestOptions {@link IRequest.Options }
+    * @return {@link ApproveAssociationResponse }
+    */
+    public async approveAssociation(approveAssociationRequest: ApproveAssociationRequest, requestOptions?: IRequest.Options): Promise<ApproveAssociationResponse> {
+        const endpoint = `${this.baseUrl}/scaAssociations`;
+        const resource = new Resource(this, endpoint);
+        
+        const request: ApproveAssociationRequest = ObjectSerializer.serialize(approveAssociationRequest, "ApproveAssociationRequest");
+        const response = await getJsonResponse<ApproveAssociationRequest, ApproveAssociationResponse>(
+            resource,
+            request,
+            { ...requestOptions, method: "PATCH" }
+        );
+
+        return ObjectSerializer.deserialize(response, "ApproveAssociationResponse");
+    }
+
+    /**
+    * @summary Get a list of devices associated with an entity
+    * @param requestOptions {@link IRequest.Options }
+    * @param entityType {@link ScaEntityType } (Required) The type of entity you want to retrieve a list of associations for.   Possible values: **accountHolder** or **paymentInstrument**.
+    * @param entityId {@link string } (Required) The unique identifier of the entity.
+    * @param pageSize {@link number } (Required) The number of items to have on a page.   Default: **5**.
+    * @param pageNumber {@link number } (Required) The index of the page to retrieve. The index of the first page is **0** (zero).   Default:  **0**.
+    * @return {@link ListAssociationsResponse }
+    */
+    public async listAssociations(entityType: ScaEntityType, entityId: string, pageSize: number, pageNumber: number, requestOptions?: IRequest.Options): Promise<ListAssociationsResponse> {
+        const endpoint = `${this.baseUrl}/scaAssociations`;
+        const resource = new Resource(this, endpoint);
+        
+        const hasDefinedQueryParams = entityType ?? entityId ?? pageSize ?? pageNumber;
+        if(hasDefinedQueryParams) {
+            if(!requestOptions) requestOptions = {};
+            if(!requestOptions.params) requestOptions.params = {};
+            if(entityType) requestOptions.params["entityType"] = entityType;
+            if(entityId) requestOptions.params["entityId"] = entityId;
+            if(pageSize) requestOptions.params["pageSize"] = pageSize;
+            if(pageNumber) requestOptions.params["pageNumber"] = pageNumber;
+        }
+        const response = await getJsonResponse<string, ListAssociationsResponse>(
+            resource,
+            "",
+            { ...requestOptions, method: "GET" }
+        );
+
+        return ObjectSerializer.deserialize(response, "ListAssociationsResponse");
+    }
+
+    /**
+    * @summary Delete association to devices
+    * @param removeAssociationRequest {@link RemoveAssociationRequest } 
+    * @param requestOptions {@link IRequest.Options }
+    * @return {@link void }
+    */
+    public async removeAssociation(removeAssociationRequest: RemoveAssociationRequest, requestOptions?: IRequest.Options): Promise<void> {
+        const endpoint = `${this.baseUrl}/scaAssociations`;
+        const resource = new Resource(this, endpoint);
+        
+        const request: RemoveAssociationRequest = ObjectSerializer.serialize(removeAssociationRequest, "RemoveAssociationRequest");
+        await getJsonResponse<RemoveAssociationRequest, void>(
+            resource,
+            request,
+            { ...requestOptions, method: "DELETE" }
+        );
+    }
+
+}