@breign/client 1.0.175 → 1.0.177

package/dist/apis/AuthApi.d.ts

@@ -10,11 +10,26 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { AuthCodeConfirmRequestUio, AuthCodeConfirmResponseUio, AuthCodeRequestUio, AuthCodeResponseUio, GetJwks200ResponseUio } from '../models/index';
+import type { ApplicationAuthorizationRequestUio, ApplicationAuthorizationResponseUio, ApplicationTokenRequestUio, ApplicationTokenResponseUio, AuthCodeConfirmRequestUio, AuthCodeConfirmResponseUio, AuthCodeRequestUio, AuthCodeResponseUio, GetJwks200ResponseUio } from '../models/index';
+export interface AuthorizeApplicationRequest {
+    responseType: AuthorizeApplicationResponseTypeEnum;
+    clientId: string;
+    redirectUri: string;
+    codeChallenge: string;
+    codeChallengeMethod: AuthorizeApplicationCodeChallengeMethodEnum;
+    state?: string;
+    deviceName?: string;
+}
 export interface ConfirmAuthCodeRequest {
     authFlowId: string;
     authCodeConfirmRequestUio: AuthCodeConfirmRequestUio;
 }
+export interface CreateApplicationAuthorizationRequest {
+    applicationAuthorizationRequestUio: ApplicationAuthorizationRequestUio;
+}
+export interface ExchangeApplicationAuthorizationCodeRequest {
+    applicationTokenRequestUio: ApplicationTokenRequestUio;
+}
 export interface GetAuthCodeRequest {
     authCodeRequestUio: AuthCodeRequestUio;
 }
@@ -31,6 +46,16 @@ export interface ToolOauthCallbackRequest {
  *
  */
 export declare class AuthApi extends runtime.BaseAPI {
+    /**
+     * Entry point of the browser authorization of a desktop application (OAuth2 authorization code with PKCE, loopback redirect per RFC 8252). The request is checked, then the browser is redirected to the consent page of Breign App, which issues the code through `POST /auth/authorizations`.
+     * Start an application authorization
+     */
+    authorizeApplicationRaw(requestParameters: AuthorizeApplicationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * Entry point of the browser authorization of a desktop application (OAuth2 authorization code with PKCE, loopback redirect per RFC 8252). The request is checked, then the browser is redirected to the consent page of Breign App, which issues the code through `POST /auth/authorizations`.
+     * Start an application authorization
+     */
+    authorizeApplication(responseType: AuthorizeApplicationResponseTypeEnum, clientId: string, redirectUri: string, codeChallenge: string, codeChallengeMethod: AuthorizeApplicationCodeChallengeMethodEnum, state?: string, deviceName?: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
     /**
      * Confirm auth code
      * Confirm auth code
@@ -41,6 +66,26 @@ export declare class AuthApi extends runtime.BaseAPI {
      * Confirm auth code
      */
     confirmAuthCode(authFlowId: string, authCodeConfirmRequestUio: AuthCodeConfirmRequestUio, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AuthCodeConfirmResponseUio>;
+    /**
+     * Called on behalf of the signed-in user once they consented to the application. Returns a single-use code, valid 5 minutes, bound to the redirect address and the PKCE challenge.
+     * Issue an application authorization code
+     */
+    createApplicationAuthorizationRaw(requestParameters: CreateApplicationAuthorizationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApplicationAuthorizationResponseUio>>;
+    /**
+     * Called on behalf of the signed-in user once they consented to the application. Returns a single-use code, valid 5 minutes, bound to the redirect address and the PKCE challenge.
+     * Issue an application authorization code
+     */
+    createApplicationAuthorization(applicationAuthorizationRequestUio: ApplicationAuthorizationRequestUio, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApplicationAuthorizationResponseUio>;
+    /**
+     * Exchanges the code issued by `POST /auth/authorizations` for an API key of the user, after checking the PKCE verifier, the client and the redirect address. The code is single use. Errors follow RFC 6749 section 5.2.
+     * Exchange an application authorization code
+     */
+    exchangeApplicationAuthorizationCodeRaw(requestParameters: ExchangeApplicationAuthorizationCodeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApplicationTokenResponseUio>>;
+    /**
+     * Exchanges the code issued by `POST /auth/authorizations` for an API key of the user, after checking the PKCE verifier, the client and the redirect address. The code is single use. Errors follow RFC 6749 section 5.2.
+     * Exchange an application authorization code
+     */
+    exchangeApplicationAuthorizationCode(applicationTokenRequestUio: ApplicationTokenRequestUio, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApplicationTokenResponseUio>;
     /**
      * Get auth code
      * Get auth code
@@ -82,3 +127,17 @@ export declare class AuthApi extends runtime.BaseAPI {
      */
     toolOauthCallback(toolId: string, code?: string, state?: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
 }
+/**
+ * @export
+ */
+export declare const AuthorizeApplicationResponseTypeEnum: {
+    readonly Code: "code";
+};
+export type AuthorizeApplicationResponseTypeEnum = typeof AuthorizeApplicationResponseTypeEnum[keyof typeof AuthorizeApplicationResponseTypeEnum];
+/**
+ * @export
+ */
+export declare const AuthorizeApplicationCodeChallengeMethodEnum: {
+    readonly S256: "S256";
+};
+export type AuthorizeApplicationCodeChallengeMethodEnum = typeof AuthorizeApplicationCodeChallengeMethodEnum[keyof typeof AuthorizeApplicationCodeChallengeMethodEnum];

package/dist/apis/AuthApi.js

@@ -46,13 +46,71 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthApi = void 0;
+exports.AuthorizeApplicationCodeChallengeMethodEnum = exports.AuthorizeApplicationResponseTypeEnum = exports.AuthApi = void 0;
 const runtime = __importStar(require("../runtime"));
 const index_1 = require("../models/index");
 /**
  *
  */
 class AuthApi extends runtime.BaseAPI {
+    /**
+     * Entry point of the browser authorization of a desktop application (OAuth2 authorization code with PKCE, loopback redirect per RFC 8252). The request is checked, then the browser is redirected to the consent page of Breign App, which issues the code through `POST /auth/authorizations`.
+     * Start an application authorization
+     */
+    async authorizeApplicationRaw(requestParameters, initOverrides) {
+        if (requestParameters['responseType'] == null) {
+            throw new runtime.RequiredError('responseType', 'Required parameter "responseType" was null or undefined when calling authorizeApplication().');
+        }
+        if (requestParameters['clientId'] == null) {
+            throw new runtime.RequiredError('clientId', 'Required parameter "clientId" was null or undefined when calling authorizeApplication().');
+        }
+        if (requestParameters['redirectUri'] == null) {
+            throw new runtime.RequiredError('redirectUri', 'Required parameter "redirectUri" was null or undefined when calling authorizeApplication().');
+        }
+        if (requestParameters['codeChallenge'] == null) {
+            throw new runtime.RequiredError('codeChallenge', 'Required parameter "codeChallenge" was null or undefined when calling authorizeApplication().');
+        }
+        if (requestParameters['codeChallengeMethod'] == null) {
+            throw new runtime.RequiredError('codeChallengeMethod', 'Required parameter "codeChallengeMethod" was null or undefined when calling authorizeApplication().');
+        }
+        const queryParameters = {};
+        if (requestParameters['responseType'] != null) {
+            queryParameters['response_type'] = requestParameters['responseType'];
+        }
+        if (requestParameters['clientId'] != null) {
+            queryParameters['client_id'] = requestParameters['clientId'];
+        }
+        if (requestParameters['redirectUri'] != null) {
+            queryParameters['redirect_uri'] = requestParameters['redirectUri'];
+        }
+        if (requestParameters['codeChallenge'] != null) {
+            queryParameters['code_challenge'] = requestParameters['codeChallenge'];
+        }
+        if (requestParameters['codeChallengeMethod'] != null) {
+            queryParameters['code_challenge_method'] = requestParameters['codeChallengeMethod'];
+        }
+        if (requestParameters['state'] != null) {
+            queryParameters['state'] = requestParameters['state'];
+        }
+        if (requestParameters['deviceName'] != null) {
+            queryParameters['device_name'] = requestParameters['deviceName'];
+        }
+        const headerParameters = {};
+        const response = await this.request({
+            path: `/auth/authorize`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.VoidApiResponse(response);
+    }
+    /**
+     * Entry point of the browser authorization of a desktop application (OAuth2 authorization code with PKCE, loopback redirect per RFC 8252). The request is checked, then the browser is redirected to the consent page of Breign App, which issues the code through `POST /auth/authorizations`.
+     * Start an application authorization
+     */
+    async authorizeApplication(responseType, clientId, redirectUri, codeChallenge, codeChallengeMethod, state, deviceName, initOverrides) {
+        await this.authorizeApplicationRaw({ responseType: responseType, clientId: clientId, redirectUri: redirectUri, codeChallenge: codeChallenge, codeChallengeMethod: codeChallengeMethod, state: state, deviceName: deviceName }, initOverrides);
+    }
     /**
      * Confirm auth code
      * Confirm auth code
@@ -87,6 +145,65 @@ class AuthApi extends runtime.BaseAPI {
         const response = await this.confirmAuthCodeRaw({ authFlowId: authFlowId, authCodeConfirmRequestUio: authCodeConfirmRequestUio }, initOverrides);
         return await response.value();
     }
+    /**
+     * Called on behalf of the signed-in user once they consented to the application. Returns a single-use code, valid 5 minutes, bound to the redirect address and the PKCE challenge.
+     * Issue an application authorization code
+     */
+    async createApplicationAuthorizationRaw(requestParameters, initOverrides) {
+        if (requestParameters['applicationAuthorizationRequestUio'] == null) {
+            throw new runtime.RequiredError('applicationAuthorizationRequestUio', 'Required parameter "applicationAuthorizationRequestUio" was null or undefined when calling createApplicationAuthorization().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-API-Key"] = await this.configuration.apiKey("X-API-Key"); // ApiKeyAuth authentication
+        }
+        const response = await this.request({
+            path: `/auth/authorizations`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: (0, index_1.ApplicationAuthorizationRequestUioToJSON)(requestParameters['applicationAuthorizationRequestUio']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.ApplicationAuthorizationResponseUioFromJSON)(jsonValue));
+    }
+    /**
+     * Called on behalf of the signed-in user once they consented to the application. Returns a single-use code, valid 5 minutes, bound to the redirect address and the PKCE challenge.
+     * Issue an application authorization code
+     */
+    async createApplicationAuthorization(applicationAuthorizationRequestUio, initOverrides) {
+        const response = await this.createApplicationAuthorizationRaw({ applicationAuthorizationRequestUio: applicationAuthorizationRequestUio }, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Exchanges the code issued by `POST /auth/authorizations` for an API key of the user, after checking the PKCE verifier, the client and the redirect address. The code is single use. Errors follow RFC 6749 section 5.2.
+     * Exchange an application authorization code
+     */
+    async exchangeApplicationAuthorizationCodeRaw(requestParameters, initOverrides) {
+        if (requestParameters['applicationTokenRequestUio'] == null) {
+            throw new runtime.RequiredError('applicationTokenRequestUio', 'Required parameter "applicationTokenRequestUio" was null or undefined when calling exchangeApplicationAuthorizationCode().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        const response = await this.request({
+            path: `/auth/token`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: (0, index_1.ApplicationTokenRequestUioToJSON)(requestParameters['applicationTokenRequestUio']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.ApplicationTokenResponseUioFromJSON)(jsonValue));
+    }
+    /**
+     * Exchanges the code issued by `POST /auth/authorizations` for an API key of the user, after checking the PKCE verifier, the client and the redirect address. The code is single use. Errors follow RFC 6749 section 5.2.
+     * Exchange an application authorization code
+     */
+    async exchangeApplicationAuthorizationCode(applicationTokenRequestUio, initOverrides) {
+        const response = await this.exchangeApplicationAuthorizationCodeRaw({ applicationTokenRequestUio: applicationTokenRequestUio }, initOverrides);
+        return await response.value();
+    }
     /**
      * Get auth code
      * Get auth code
@@ -202,3 +319,15 @@ class AuthApi extends runtime.BaseAPI {
     }
 }
 exports.AuthApi = AuthApi;
+/**
+ * @export
+ */
+exports.AuthorizeApplicationResponseTypeEnum = {
+    Code: 'code'
+};
+/**
+ * @export
+ */
+exports.AuthorizeApplicationCodeChallengeMethodEnum = {
+    S256: 'S256'
+};

package/dist/apis/IntegrationsApi.d.ts

@@ -0,0 +1,174 @@
+/**
+ * brain-client
+ * Api ands models for brain-app and brain-app
+ *
+ * The version of the OpenAPI document: 0.0.0-SNAPSHOT
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import * as runtime from '../runtime';
+import type { ExternalEventUio, GitlabBotAccountCreateUio, GitlabBotAccountSummaryUio, GitlabBotAccountUio, GitlabBotAccountUpdateUio, GitlabConnectionTestResultUio, GitlabIntegrationCreateUio, GitlabIntegrationDetailUio, GitlabIntegrationUio, GitlabIntegrationUpdateUio, GitlabRoutingTestResultUio, GitlabRoutingTestUio } from '../models/index';
+export interface CreateGitlabBotAccountRequest {
+    organizationId: string;
+    integrationId: string;
+    gitlabBotAccountCreateUio: GitlabBotAccountCreateUio;
+}
+export interface CreateGitlabIntegrationRequest {
+    organizationId: string;
+    gitlabIntegrationCreateUio: GitlabIntegrationCreateUio;
+}
+export interface DeleteGitlabBotAccountRequest {
+    organizationId: string;
+    integrationId: string;
+    accountId: string;
+}
+export interface DeleteGitlabIntegrationRequest {
+    organizationId: string;
+    integrationId: string;
+}
+export interface GetGitlabIntegrationRequest {
+    organizationId: string;
+    integrationId: string;
+}
+export interface ListGitlabIntegrationEventsRequest {
+    organizationId: string;
+    integrationId: string;
+}
+export interface ListGitlabIntegrationsRequest {
+    organizationId: string;
+}
+export interface ListOrganizationGitlabBotAccountsRequest {
+    organizationId: string;
+}
+export interface TestGitlabConnectionRequest {
+    organizationId: string;
+    integrationId: string;
+}
+export interface TestGitlabRoutingRequest {
+    organizationId: string;
+    integrationId: string;
+    gitlabRoutingTestUio: GitlabRoutingTestUio;
+}
+export interface UpdateGitlabBotAccountRequest {
+    organizationId: string;
+    integrationId: string;
+    accountId: string;
+    gitlabBotAccountUpdateUio: GitlabBotAccountUpdateUio;
+}
+export interface UpdateGitlabIntegrationRequest {
+    organizationId: string;
+    integrationId: string;
+    gitlabIntegrationUpdateUio: GitlabIntegrationUpdateUio;
+}
+/**
+ *
+ */
+export declare class IntegrationsApi extends runtime.BaseAPI {
+    /**
+     * The token is checked against GitLab (GET /user). The service user must be a member of the organization, the named agents must belong to it, and no two callable agents may share a name once normalized (409 DUPLICATE_AGENT_NAMES, with the duplicates).
+     * Add a bot account to a GitLab integration
+     */
+    createGitlabBotAccountRaw(requestParameters: CreateGitlabBotAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GitlabBotAccountUio>>;
+    /**
+     * The token is checked against GitLab (GET /user). The service user must be a member of the organization, the named agents must belong to it, and no two callable agents may share a name once normalized (409 DUPLICATE_AGENT_NAMES, with the duplicates).
+     * Add a bot account to a GitLab integration
+     */
+    createGitlabBotAccount(organizationId: string, integrationId: string, gitlabBotAccountCreateUio: GitlabBotAccountCreateUio, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GitlabBotAccountUio>;
+    /**
+     * A webhook secret is generated; it is returned with the integration.
+     * Link a GitLab instance to the organization
+     */
+    createGitlabIntegrationRaw(requestParameters: CreateGitlabIntegrationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GitlabIntegrationDetailUio>>;
+    /**
+     * A webhook secret is generated; it is returned with the integration.
+     * Link a GitLab instance to the organization
+     */
+    createGitlabIntegration(organizationId: string, gitlabIntegrationCreateUio: GitlabIntegrationCreateUio, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GitlabIntegrationDetailUio>;
+    /**
+     * Remove a bot account
+     */
+    deleteGitlabBotAccountRaw(requestParameters: DeleteGitlabBotAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * Remove a bot account
+     */
+    deleteGitlabBotAccount(organizationId: string, integrationId: string, accountId: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Delete a GitLab integration, its bot accounts and its events
+     */
+    deleteGitlabIntegrationRaw(requestParameters: DeleteGitlabIntegrationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * Delete a GitLab integration, its bot accounts and its events
+     */
+    deleteGitlabIntegration(organizationId: string, integrationId: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Get a GitLab integration, its webhook secret and its bot accounts
+     */
+    getGitlabIntegrationRaw(requestParameters: GetGitlabIntegrationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GitlabIntegrationDetailUio>>;
+    /**
+     * Get a GitLab integration, its webhook secret and its bot accounts
+     */
+    getGitlabIntegration(organizationId: string, integrationId: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GitlabIntegrationDetailUio>;
+    /**
+     * The latest mentions received by a GitLab integration
+     */
+    listGitlabIntegrationEventsRaw(requestParameters: ListGitlabIntegrationEventsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<ExternalEventUio>>>;
+    /**
+     * The latest mentions received by a GitLab integration
+     */
+    listGitlabIntegrationEvents(organizationId: string, integrationId: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<ExternalEventUio>>;
+    /**
+     * List the GitLab integrations of an organization
+     */
+    listGitlabIntegrationsRaw(requestParameters: ListGitlabIntegrationsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<GitlabIntegrationUio>>>;
+    /**
+     * List the GitLab integrations of an organization
+     */
+    listGitlabIntegrations(organizationId: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<GitlabIntegrationUio>>;
+    /**
+     * The GitLab bot accounts of the organization, to pick one in an automation
+     */
+    listOrganizationGitlabBotAccountsRaw(requestParameters: ListOrganizationGitlabBotAccountsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<GitlabBotAccountSummaryUio>>>;
+    /**
+     * The GitLab bot accounts of the organization, to pick one in an automation
+     */
+    listOrganizationGitlabBotAccounts(organizationId: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<GitlabBotAccountSummaryUio>>;
+    /**
+     * An accepted token puts its account back in service; a rejected one marks it token_invalid.
+     * Test the connection of every bot account (GET /user with its token)
+     */
+    testGitlabConnectionRaw(requestParameters: TestGitlabConnectionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<GitlabConnectionTestResultUio>>>;
+    /**
+     * An accepted token puts its account back in service; a rejected one marks it token_invalid.
+     * Test the connection of every bot account (GET /user with its token)
+     */
+    testGitlabConnection(organizationId: string, integrationId: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<GitlabConnectionTestResultUio>>;
+    /**
+     * Preview what a GitLab comment would trigger
+     */
+    testGitlabRoutingRaw(requestParameters: TestGitlabRoutingRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GitlabRoutingTestResultUio>>;
+    /**
+     * Preview what a GitLab comment would trigger
+     */
+    testGitlabRouting(organizationId: string, integrationId: string, gitlabRoutingTestUio: GitlabRoutingTestUio, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GitlabRoutingTestResultUio>;
+    /**
+     * Update a bot account (agents, service user, token, status)
+     */
+    updateGitlabBotAccountRaw(requestParameters: UpdateGitlabBotAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GitlabBotAccountUio>>;
+    /**
+     * Update a bot account (agents, service user, token, status)
+     */
+    updateGitlabBotAccount(organizationId: string, integrationId: string, accountId: string, gitlabBotAccountUpdateUio: GitlabBotAccountUpdateUio, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GitlabBotAccountUio>;
+    /**
+     * Changing `baseUrl` wipes the token of every bot account (status token_invalid, lastError BASE_URL_CHANGED): a token is never sent to another host than the one it was given for.
+     * Update a GitLab integration
+     */
+    updateGitlabIntegrationRaw(requestParameters: UpdateGitlabIntegrationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GitlabIntegrationDetailUio>>;
+    /**
+     * Changing `baseUrl` wipes the token of every bot account (status token_invalid, lastError BASE_URL_CHANGED): a token is never sent to another host than the one it was given for.
+     * Update a GitLab integration
+     */
+    updateGitlabIntegration(organizationId: string, integrationId: string, gitlabIntegrationUpdateUio: GitlabIntegrationUpdateUio, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GitlabIntegrationDetailUio>;
+}