@iblai/iblai-api 0.0.2-core → 0.0.12-scan-core

package/src/services/ProviderAssociationService.ts

@@ -12,13 +12,14 @@ export class ProviderAssociationService {
      * Updates:
      * - Platform launch state
      * - Association configuration status
-     * @param launchId
      * @returns any
      * @throws ApiError
      */
-    public static providerAssociationStripeCallbackRetrieve(
+    public static providerAssociationStripeCallbackRetrieve({
+        launchId,
+    }: {
         launchId: string,
-    ): CancelablePromise<{
+    }): CancelablePromise<{
         message?: string;
     }> {
         return __request(OpenAPI, {

package/src/services/ProvidersService.ts

@@ -12,6 +12,7 @@ import type { BaseResponse } from '../models/BaseResponse';
 import type { GCPTenantLaunchRequest } from '../models/GCPTenantLaunchRequest';
 import type { GooglePayAccountResponse } from '../models/GooglePayAccountResponse';
 import type { GooglePayVerifyToken } from '../models/GooglePayVerifyToken';
+import type { StripeNewUserTenantLaunchRequest } from '../models/StripeNewUserTenantLaunchRequest';
 import type { TenantLaunchResponse } from '../models/TenantLaunchResponse';
 import type { VerifyGCPMarketPlaceRequest } from '../models/VerifyGCPMarketPlaceRequest';
 import type { VerifyGCPMarketPlaceResponse } from '../models/VerifyGCPMarketPlaceResponse';
@@ -21,13 +22,14 @@ import { request as __request } from '../core/request';
 export class ProvidersService {
     /**
      * Associate an Apple account with a user known user
-     * @param requestBody
      * @returns AssociateAccountResponse
      * @throws ApiError
      */
-    public static providersAppleAssociateAccountCreate(
+    public static providersAppleAssociateAccountCreate({
+        requestBody,
+    }: {
         requestBody: AssociateAppleAccount,
-    ): CancelablePromise<AssociateAccountResponse> {
+    }): CancelablePromise<AssociateAccountResponse> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/providers/apple/associate-account/',
@@ -48,13 +50,14 @@ export class ProvidersService {
     }
     /**
      * Returns information about a user subscription status
-     * @param requestBody
      * @returns AppleSubscriptionStatusView
      * @throws ApiError
      */
-    public static providersAppleSubscriptionStatusCreate(
+    public static providersAppleSubscriptionStatusCreate({
+        requestBody,
+    }: {
         requestBody?: AppleSubscriptionStatusRequest,
-    ): CancelablePromise<AppleSubscriptionStatusView> {
+    }): CancelablePromise<AppleSubscriptionStatusView> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/providers/apple/subscription-status/',
@@ -64,13 +67,14 @@ export class ProvidersService {
     }
     /**
      * Checks if a provided transaction_id is valid
-     * @param requestBody
      * @returns BaseResponse
      * @throws ApiError
      */
-    public static providersAppleValidateTransactionIdCreate(
+    public static providersAppleValidateTransactionIdCreate({
+        requestBody,
+    }: {
         requestBody: AppleVerifyTransactionId,
-    ): CancelablePromise<BaseResponse> {
+    }): CancelablePromise<BaseResponse> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/providers/apple/validate-transaction-id/',
@@ -109,13 +113,14 @@ export class ProvidersService {
      * We cannot expose launching a tenant to an authorized user hence the need for the API
      *
      * The API validates the x_amzn_marketplace_token and then proxies the request to the Platform Launch API
-     * @param requestBody
      * @returns TenantLaunchResponse
      * @throws ApiError
      */
-    public static providersAwsLaunchTenantCreate(
+    public static providersAwsLaunchTenantCreate({
+        requestBody,
+    }: {
         requestBody: AWSTenantLaunchRequest,
-    ): CancelablePromise<TenantLaunchResponse> {
+    }): CancelablePromise<TenantLaunchResponse> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/providers/aws/launch-tenant/',
@@ -164,13 +169,14 @@ export class ProvidersService {
      *
      * Set CREATE_ORGANIZATION_URL in GlobalConfigurationFetcher to the URL of the GCP marketplace create organization
      * page
-     * @param productId
      * @returns any No response body
      * @throws ApiError
      */
-    public static providersGcpCreateOrganizationCreate2(
+    public static providersGcpCreateOrganizationCreate2({
+        productId,
+    }: {
         productId: string,
-    ): CancelablePromise<any> {
+    }): CancelablePromise<any> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/providers/gcp/create-organization/{product_id}/',
@@ -195,13 +201,14 @@ export class ProvidersService {
      * We cannot expose launching a tenant to an authorized user hence the need for the API
      *
      * The API validates the x_gcp_marketplace_token and then proxies the request to the Platform Launc API
-     * @param requestBody
      * @returns TenantLaunchResponse
      * @throws ApiError
      */
-    public static providersGcpLaunchTenantCreate(
+    public static providersGcpLaunchTenantCreate({
+        requestBody,
+    }: {
         requestBody: GCPTenantLaunchRequest,
-    ): CancelablePromise<TenantLaunchResponse> {
+    }): CancelablePromise<TenantLaunchResponse> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/providers/gcp/launch-tenant/',
@@ -210,13 +217,14 @@ export class ProvidersService {
         });
     }
     /**
-     * @param requestBody
      * @returns VerifyGCPMarketPlaceResponse
      * @throws ApiError
      */
-    public static providersGcpValidateSignupTokenCreate(
+    public static providersGcpValidateSignupTokenCreate({
+        requestBody,
+    }: {
         requestBody: VerifyGCPMarketPlaceRequest,
-    ): CancelablePromise<VerifyGCPMarketPlaceResponse> {
+    }): CancelablePromise<VerifyGCPMarketPlaceResponse> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/providers/gcp/validate-signup-token/',
@@ -226,13 +234,14 @@ export class ProvidersService {
     }
     /**
      * Google Allows us to pass an obfuscated account id to be sent to during a subscription purchase
-     * @param bundleId
      * @returns GooglePayAccountResponse
      * @throws ApiError
      */
-    public static providersGooglePayGetAccountRetrieve(
+    public static providersGooglePayGetAccountRetrieve({
+        bundleId,
+    }: {
         bundleId: string,
-    ): CancelablePromise<GooglePayAccountResponse> {
+    }): CancelablePromise<GooglePayAccountResponse> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/providers/google-pay/get-account/{bundle_id}',
@@ -254,13 +263,14 @@ export class ProvidersService {
     }
     /**
      * Associate a Google Pay account with a known user
-     * @param requestBody
      * @returns BaseResponse
      * @throws ApiError
      */
-    public static providersGooglePayValidateTransactionIdCreate(
+    public static providersGooglePayValidateTransactionIdCreate({
+        requestBody,
+    }: {
         requestBody: GooglePayVerifyToken,
-    ): CancelablePromise<BaseResponse> {
+    }): CancelablePromise<BaseResponse> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/providers/google-pay/validate-transaction-id/',
@@ -268,4 +278,25 @@ export class ProvidersService {
             mediaType: 'application/json',
         });
     }
+    /**
+     * Proxy to the Platform launch API
+     *
+     * We cannot expose launching a tenant to an unauthorized user hence the need for the API
+     *
+     * The API validates the stripe_checkout_id and then proxies the request to the Platform Launch API
+     * @returns TenantLaunchResponse
+     * @throws ApiError
+     */
+    public static providersStripeCreateOrganizationCreate({
+        requestBody,
+    }: {
+        requestBody: StripeNewUserTenantLaunchRequest,
+    }): CancelablePromise<TenantLaunchResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/providers/stripe/create-organization/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
 }

package/src/services/ProvisionService.ts

@@ -12,13 +12,14 @@ export class ProvisionService {
      *
      * request body:
      * {"config_name": "demo_config}
-     * @param configName
      * @returns any No response body
      * @throws ApiError
      */
-    public static provisionCreate(
+    public static provisionCreate({
+        configName,
+    }: {
         configName: string,
-    ): CancelablePromise<any> {
+    }): CancelablePromise<any> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/provision/{config_name}/',

package/src/services/RecommendationsService.ts

@@ -10,15 +10,16 @@ export class RecommendationsService {
     /**
      * API endpoint that returns a search api url prepopulated with context data
      * See http://localhost:8000/api/schema/swagger-ui/#/recommendations
-     * @param org
-     * @param userId
      * @returns RecommendationSearchAPI
      * @throws ApiError
      */
-    public static recommendationsOrgsUsersRetrieve(
+    public static recommendationsOrgsUsersRetrieve({
+        org,
+        userId,
+    }: {
         org: string,
         userId: string,
-    ): CancelablePromise<RecommendationSearchAPI> {
+    }): CancelablePromise<RecommendationSearchAPI> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/recommendations/orgs/{org}/users/{user_id}/',

package/src/services/ReportsService.ts

@@ -24,13 +24,14 @@ export class ReportsService {
      *
      * Returns:
      * A list of report objects with their metadata and status information.
-     * @param org
      * @returns ReportList
      * @throws ApiError
      */
-    public static reportsOrgsRetrieve(
+    public static reportsOrgsRetrieve({
+        org,
+    }: {
         org: string,
-    ): CancelablePromise<ReportList> {
+    }): CancelablePromise<ReportList> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/reports/orgs/{org}/',
@@ -56,15 +57,16 @@ export class ReportsService {
      *
      * Error Responses:
      * 404 Not Found: If the specified report type doesn't exist
-     * @param org
-     * @param reportName
      * @returns ReportDetail
      * @throws ApiError
      */
-    public static reportsOrgsRetrieve2(
+    public static reportsOrgsRetrieve2({
+        org,
+        reportName,
+    }: {
         org: string,
         reportName: string,
-    ): CancelablePromise<ReportDetail> {
+    }): CancelablePromise<ReportDetail> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/reports/orgs/{org}/{report_name}',
@@ -116,15 +118,16 @@ export class ReportsService {
      * 400 Bad Request: Invalid parameters or report configuration
      * 404 Not Found: Report type not found
      * 403 Forbidden: User doesn't have permission for the requested report
-     * @param org
-     * @param requestBody
      * @returns ReportCreate
      * @throws ApiError
      */
-    public static reportsOrgsNewCreate(
+    public static reportsOrgsNewCreate({
+        org,
+        requestBody,
+    }: {
         org: string,
         requestBody?: ReportRequest,
-    ): CancelablePromise<ReportCreate> {
+    }): CancelablePromise<ReportCreate> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/reports/orgs/{org}/new',
@@ -148,13 +151,14 @@ export class ReportsService {
      * - status: Current status of the report if it has been previously requested
      *
      * The status will include details like the report ID, state, and download URL if completed.
-     * @param key
      * @returns ReportList
      * @throws ApiError
      */
-    public static reportsPlatformsRetrieve(
+    public static reportsPlatformsRetrieve({
+        key,
+    }: {
         key: string,
-    ): CancelablePromise<ReportList> {
+    }): CancelablePromise<ReportList> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/reports/platforms/{key}/',
@@ -165,15 +169,16 @@ export class ReportsService {
     }
     /**
      * Returns details of a specific report type including its status if previously requested.
-     * @param key
-     * @param reportName
      * @returns ReportDetail
      * @throws ApiError
      */
-    public static reportsPlatformsRetrieve2(
+    public static reportsPlatformsRetrieve2({
+        key,
+        reportName,
+    }: {
         key: string,
         reportName: string,
-    ): CancelablePromise<ReportDetail> {
+    }): CancelablePromise<ReportDetail> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/reports/platforms/{key}/{report_name}',
@@ -196,15 +201,16 @@ export class ReportsService {
      * - force: (optional) Force generation of a new report even if one exists
      * - filters: (optional) Additional filters for the report
      * - departments: (optional) Department IDs to filter by
-     * @param key
-     * @param requestBody
      * @returns ReportCreate
      * @throws ApiError
      */
-    public static reportsPlatformsNewCreate(
+    public static reportsPlatformsNewCreate({
+        key,
+        requestBody,
+    }: {
         key: string,
         requestBody?: ReportRequest,
-    ): CancelablePromise<ReportCreate> {
+    }): CancelablePromise<ReportCreate> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/reports/platforms/{key}/new',

package/src/services/RolesService.ts

@@ -28,15 +28,16 @@ export class RolesService {
      * Error Responses:
      * 400 Bad Request: If the user doesn't exist in the platform or has no desired role
      * 404 Not Found: If the specified platform doesn't exist
-     * @param org
-     * @param username
      * @returns DesiredRole
      * @throws ApiError
      */
-    public static rolesPlatformOrgsRolesUsersDesiredRolesRetrieve(
+    public static rolesPlatformOrgsRolesUsersDesiredRolesRetrieve({
+        org,
+        username,
+    }: {
         org: string,
         username: string,
-    ): CancelablePromise<DesiredRole> {
+    }): CancelablePromise<DesiredRole> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/roles/platform/orgs/{org}/roles/users/{username}/desired-roles/',
@@ -66,15 +67,16 @@ export class RolesService {
      * Error Responses:
      * 400 Bad Request: If the user doesn't exist in the platform or has no reported role
      * 404 Not Found: If the specified platform doesn't exist
-     * @param org
-     * @param username
      * @returns ReportedRole
      * @throws ApiError
      */
-    public static rolesPlatformOrgsRolesUsersReportedRolesRetrieve(
+    public static rolesPlatformOrgsRolesUsersReportedRolesRetrieve({
+        org,
+        username,
+    }: {
         org: string,
         username: string,
-    ): CancelablePromise<ReportedRole> {
+    }): CancelablePromise<ReportedRole> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/roles/platform/orgs/{org}/roles/users/{username}/reported-roles/',