@fenixalliance/abs-api-client 1.0.0

package/clients/tenantService/services/FenixAllianceAbsWebService.ts

@@ -0,0 +1,293 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { AccessTokenResponse } from '../models/AccessTokenResponse';
+import type { ForgotPasswordRequest } from '../models/ForgotPasswordRequest';
+import type { InfoRequest } from '../models/InfoRequest';
+import type { InfoResponse } from '../models/InfoResponse';
+import type { LoginRequest } from '../models/LoginRequest';
+import type { RefreshRequest } from '../models/RefreshRequest';
+import type { RegisterRequest } from '../models/RegisterRequest';
+import type { ResendConfirmationEmailRequest } from '../models/ResendConfirmationEmailRequest';
+import type { ResetPasswordRequest } from '../models/ResetPasswordRequest';
+import type { TwoFactorRequest } from '../models/TwoFactorRequest';
+import type { TwoFactorResponse } from '../models/TwoFactorResponse';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class FenixAllianceAbsWebService {
+    /**
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static getVersion(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/version',
+        });
+    }
+    /**
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static getHealth(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/health',
+        });
+    }
+    /**
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static getHello(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/hello',
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postRegister(
+        requestBody?: RegisterRequest,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/register',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request`,
+            },
+        });
+    }
+    /**
+     * @param useCookies
+     * @param useSessionCookies
+     * @param requestBody
+     * @returns AccessTokenResponse Success
+     * @throws ApiError
+     */
+    public static postLogin(
+        useCookies?: boolean,
+        useSessionCookies?: boolean,
+        requestBody?: LoginRequest,
+    ): CancelablePromise<AccessTokenResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/login',
+            query: {
+                'useCookies': useCookies,
+                'useSessionCookies': useSessionCookies,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns AccessTokenResponse Success
+     * @throws ApiError
+     */
+    public static postRefresh(
+        requestBody?: RefreshRequest,
+    ): CancelablePromise<AccessTokenResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/refresh',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * @param userId
+     * @param code
+     * @param changedEmail
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static mapIdentityApiConfirmEmail(
+        userId?: string,
+        code?: string,
+        changedEmail?: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/confirmEmail',
+            query: {
+                'userId': userId,
+                'code': code,
+                'changedEmail': changedEmail,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postResendConfirmationEmail(
+        requestBody?: ResendConfirmationEmailRequest,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/resendConfirmationEmail',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postForgotPassword(
+        requestBody?: ForgotPasswordRequest,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/forgotPassword',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request`,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postResetPassword(
+        requestBody?: ResetPasswordRequest,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/resetPassword',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request`,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns TwoFactorResponse Success
+     * @throws ApiError
+     */
+    public static postManage2Fa(
+        requestBody?: TwoFactorRequest,
+    ): CancelablePromise<TwoFactorResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/manage/2fa',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @returns InfoResponse Success
+     * @throws ApiError
+     */
+    public static getManageInfo(): CancelablePromise<InfoResponse> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/manage/info',
+            errors: {
+                400: `Bad Request`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns InfoResponse Success
+     * @throws ApiError
+     */
+    public static postManageInfo(
+        requestBody?: InfoRequest,
+    ): CancelablePromise<InfoResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/manage/info',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param formData
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postAccountPerformExternalLogin(
+        formData?: {
+            provider: string;
+            returnUrl: string;
+        },
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/Account/PerformExternalLogin',
+            formData: formData,
+            mediaType: 'multipart/form-data',
+        });
+    }
+    /**
+     * @param formData
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postAccountLogout(
+        formData?: {
+            returnUrl: string;
+        },
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/Account/Logout',
+            formData: formData,
+            mediaType: 'multipart/form-data',
+        });
+    }
+    /**
+     * @param formData
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postAccountManageLinkExternalLogin(
+        formData?: {
+            provider: string;
+        },
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/Account/Manage/LinkExternalLogin',
+            formData: formData,
+            mediaType: 'multipart/form-data',
+        });
+    }
+    /**
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postAccountManageDownloadPersonalData(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/Account/Manage/DownloadPersonalData',
+        });
+    }
+}

package/clients/tenantService/services/TenantsService.ts

@@ -0,0 +1,354 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { BusinessCreateDto } from '../models/BusinessCreateDto';
+import type { BusinessDto } from '../models/BusinessDto';
+import type { BusinessEnrollmentDto } from '../models/BusinessEnrollmentDto';
+import type { BusinessEnrollmentDtoEnvelope } from '../models/BusinessEnrollmentDtoEnvelope';
+import type { BusinessEnrollmentDtoIReadOnlyListEnvelope } from '../models/BusinessEnrollmentDtoIReadOnlyListEnvelope';
+import type { NotificationDtoListEnvelope } from '../models/NotificationDtoListEnvelope';
+import type { StringListEnvelope } from '../models/StringListEnvelope';
+import type { WalletDtoTaskEnvelope } from '../models/WalletDtoTaskEnvelope';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class TenantsService {
+    /**
+     * @returns BusinessDto Success
+     * @throws ApiError
+     */
+    public static getApiV2TenantsCurrent(): CancelablePromise<BusinessDto> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/Current',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @returns BusinessDto Success
+     * @throws ApiError
+     */
+    public static getApiV2Tenants(
+        businessId: string,
+    ): CancelablePromise<BusinessDto> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{businessId}',
+            path: {
+                'businessId': businessId,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @returns WalletDtoTaskEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2TenantsWallet(
+        businessId: string,
+    ): CancelablePromise<WalletDtoTaskEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{businessId}/Wallet',
+            path: {
+                'businessId': businessId,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static getApiV2TenantsSocialProfile(
+        businessId: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{businessId}/SocialProfile',
+            path: {
+                'businessId': businessId,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static getApiV2TenantsCart(
+        businessId: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{businessId}/Cart',
+            path: {
+                'businessId': businessId,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @returns BusinessEnrollmentDtoIReadOnlyListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2TenantsEnrollments(
+        businessId: string,
+    ): CancelablePromise<BusinessEnrollmentDtoIReadOnlyListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{businessId}/Enrollments',
+            path: {
+                'businessId': businessId,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @param enrollmentId
+     * @returns BusinessEnrollmentDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2TenantsEnrollments1(
+        businessId: string,
+        enrollmentId: string,
+    ): CancelablePromise<BusinessEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{businessId}/Enrollments/{enrollmentId}',
+            path: {
+                'businessId': businessId,
+                'enrollmentId': enrollmentId,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @param enrollmentId
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static getApiV2TenantsEnrollmentsLicenses(
+        businessId: string,
+        enrollmentId: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{businessId}/Enrollments/{EnrollmentID}/Licenses',
+            path: {
+                'businessId': businessId,
+                'enrollmentID': enrollmentId,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @param enrollmentId
+     * @returns StringListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2TenantsEnrollmentsPermissions(
+        businessId: string,
+        enrollmentId: string,
+    ): CancelablePromise<StringListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{businessId}/Enrollments/{EnrollmentID}/Permissions',
+            path: {
+                'businessId': businessId,
+                'enrollmentID': enrollmentId,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static getApiV2TenantsLicenses(
+        businessId: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{businessId}/Licenses',
+            path: {
+                'businessId': businessId,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postApiV2Tenants(
+        requestBody?: BusinessCreateDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/Tenants',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * @param businessId
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static deleteApiV2Tenants(
+        businessId: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/Tenants',
+            query: {
+                'businessId': businessId,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @param backTo
+     * @param enableRedirect
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static getApiV2TenantsSelect(
+        businessId: string,
+        backTo?: string,
+        enableRedirect: boolean = true,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{businessId}/Select',
+            path: {
+                'businessId': businessId,
+            },
+            query: {
+                'backTo': backTo,
+                'enableRedirect': enableRedirect,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @param backTo
+     * @param enableRedirect
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postApiV2TenantsSelect(
+        businessId: string,
+        backTo?: string,
+        enableRedirect: boolean = true,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/Tenants/{businessId}/Select',
+            path: {
+                'businessId': businessId,
+            },
+            query: {
+                'backTo': backTo,
+                'enableRedirect': enableRedirect,
+            },
+        });
+    }
+    /**
+     * @param backTo
+     * @param enableRedirect
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static getApiV2TenantsDeselect(
+        backTo?: string,
+        enableRedirect: boolean = true,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/Deselect',
+            query: {
+                'backTo': backTo,
+                'enableRedirect': enableRedirect,
+            },
+        });
+    }
+    /**
+     * @param backTo
+     * @param enableRedirect
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postApiV2TenantsDeselect(
+        backTo?: string,
+        enableRedirect: boolean = true,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/Tenants/Deselect',
+            query: {
+                'backTo': backTo,
+                'enableRedirect': enableRedirect,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static getApiV2TenantsAppAuthorization(
+        businessId: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{businessId}/AppAuthorization',
+            path: {
+                'businessId': businessId,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @returns NotificationDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2TenantsNotifications(
+        businessId: string,
+    ): CancelablePromise<NotificationDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{businessId}/Notifications',
+            path: {
+                'businessId': businessId,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @returns BusinessEnrollmentDto Success
+     * @throws ApiError
+     */
+    public static getApiV2TenantsUserEnrollments(
+        businessId: string,
+    ): CancelablePromise<Array<BusinessEnrollmentDto>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{businessId}/UserEnrollments',
+            path: {
+                'businessId': businessId,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@fenixalliance/abs-api-client",
+  "version": "1.0.0",
+  "description": "Clients and types for the ABS Platform API, provided by Fenix Alliance.",
+  "keywords": [
+    "ABS",
+    "API",
+    "Fenix Alliance",
+    "client",
+    "types",
+    "openapi"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "author": "Fenix Alliance <contact@fenix-alliance.com>",
+  "homepage": "https://fenix-alliance.com/abs-api-client",
+  "license": "MIT",
+  "directories": {
+    "lib": "lib"
+  },
+  "main": "lib/index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fenixalliance/abs.docs"
+  },
+  "bugs": {
+    "url": "https://github.com/fenixalliance/abs.docs"
+  },
+  "devDependencies": {
+    "openapi-typescript": "^6.7.4",
+    "openapi-typescript-codegen": "^0.27.0",
+    "eslint": "^7.32.0",
+    "typescript": "^4.5.2"
+  },
+  "peerDependencies": {},
+  "dependencies": {}
+}