@unito/integration-cli 0.60.1 → 0.60.2

package/dist/.eslintrc.d.ts

@@ -6,6 +6,7 @@ declare let _extends: string[];
 export { _extends as extends };
 export declare let rules: {
     'no-console': string;
+    '@typescript-eslint/no-explicit-any': string;
 };
 export declare let ignorePatterns: string[];
 export declare let overrides: {

package/dist/.eslintrc.js

@@ -12,6 +12,7 @@ module.exports = {
     ],
     rules: {
         'no-console': 'off',
+        '@typescript-eslint/no-explicit-any': 'off',
     },
     ignorePatterns: [
         'boilerplate',

package/dist/src/services/integrationsPlatform.d.ts

@@ -1,4 +1,4 @@
-import IntegrationsPlatform from '@unito/integrations-platform-client';
+import * as IntegrationsPlatform from './integrationsPlatformClient';
 import { Environment } from '../resources/globalConfiguration';
 import { Configuration } from '../configurationTypes';
 export type User = IntegrationsPlatform.User;

package/dist/src/services/integrationsPlatform.js

@@ -3,40 +3,40 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCredential = exports.updateIntegration = exports.getIntegrationEvents = exports.inviteUserToIntegration = exports.createIntegration = exports.publishIntegration = exports.getIntegrations = exports.getIntegrationByName = exports.getIntegration = exports.reencryptData = exports.decryptData = exports.encryptData = exports.getProfile = exports.setApiKey = exports.getApiKey = exports.setEnvironment = exports.Servers = exports.HttpError = void 0;
 const tslib_1 = require("tslib");
 const fs = tslib_1.__importStar(require("fs"));
-const integrations_platform_client_1 = tslib_1.__importDefault(require("@unito/integrations-platform-client"));
+const IntegrationsPlatform = tslib_1.__importStar(require("./integrationsPlatformClient"));
 const globalConfiguration_1 = require("../resources/globalConfiguration");
-const { HttpError } = integrations_platform_client_1.default;
+const { HttpError } = IntegrationsPlatform;
 exports.HttpError = HttpError;
 exports.Servers = {
-    [globalConfiguration_1.Environment.Local]: integrations_platform_client_1.default.servers.local,
-    [globalConfiguration_1.Environment.Staging]: integrations_platform_client_1.default.servers.staging,
-    [globalConfiguration_1.Environment.Production]: integrations_platform_client_1.default.servers.production,
+    [globalConfiguration_1.Environment.Local]: IntegrationsPlatform.servers.local,
+    [globalConfiguration_1.Environment.Staging]: IntegrationsPlatform.servers.staging,
+    [globalConfiguration_1.Environment.Production]: IntegrationsPlatform.servers.production,
 };
 function setEnvironment(environment) {
-    integrations_platform_client_1.default.defaults.fetch = fetch;
-    integrations_platform_client_1.default.defaults.baseUrl = exports.Servers[environment];
+    IntegrationsPlatform.defaults.fetch = fetch;
+    IntegrationsPlatform.defaults.baseUrl = exports.Servers[environment];
 }
 exports.setEnvironment = setEnvironment;
 function getApiKey() {
-    const header = integrations_platform_client_1.default.defaults.headers?.Authorization?.toString();
+    const header = IntegrationsPlatform.defaults.headers?.Authorization?.toString();
     return header?.split(' ')?.at(1);
 }
 exports.getApiKey = getApiKey;
 function setApiKey(apiKey) {
     if (apiKey) {
-        integrations_platform_client_1.default.defaults.headers = { Authorization: `Bearer ${apiKey}` };
+        IntegrationsPlatform.defaults.headers = { Authorization: `Bearer ${apiKey}` };
     }
     else {
-        integrations_platform_client_1.default.defaults.headers = {};
+        IntegrationsPlatform.defaults.headers = {};
     }
 }
 exports.setApiKey = setApiKey;
 async function getProfile() {
-    return integrations_platform_client_1.default.getProfile();
+    return IntegrationsPlatform.getProfile();
 }
 exports.getProfile = getProfile;
 async function encryptData(integrationName, data, sensitive) {
-    return integrations_platform_client_1.default.encryptData({
+    return IntegrationsPlatform.encryptData({
         integrationName,
         data,
         sensitive,
@@ -44,14 +44,14 @@ async function encryptData(integrationName, data, sensitive) {
 }
 exports.encryptData = encryptData;
 async function decryptData(integrationName, data) {
-    return integrations_platform_client_1.default.decryptData({
+    return IntegrationsPlatform.decryptData({
         integrationName,
         data,
     });
 }
 exports.decryptData = decryptData;
 async function reencryptData(integrationName, encryptedData, newIntegrationName) {
-    return integrations_platform_client_1.default.reencryptData({
+    return IntegrationsPlatform.reencryptData({
         integrationName,
         encryptedData,
         newIntegrationName,
@@ -59,11 +59,11 @@ async function reencryptData(integrationName, encryptedData, newIntegrationName)
 }
 exports.reencryptData = reencryptData;
 async function getIntegration(integrationId) {
-    return integrations_platform_client_1.default.getIntegrationById(integrationId);
+    return IntegrationsPlatform.getIntegrationById(integrationId);
 }
 exports.getIntegration = getIntegration;
 async function getIntegrationByName(integrationName) {
-    return integrations_platform_client_1.default.getIntegrationByName(integrationName);
+    return IntegrationsPlatform.getIntegrationByName(integrationName);
 }
 exports.getIntegrationByName = getIntegrationByName;
 async function getIntegrations() {
@@ -72,7 +72,7 @@ async function getIntegrations() {
     const limit = 100;
     let nextPageOffset = 0;
     do {
-        page = await integrations_platform_client_1.default.getIntegrations({
+        page = await IntegrationsPlatform.getIntegrations({
             pagination: { offset: nextPageOffset, limit },
         });
         nextPageOffset += limit;
@@ -84,27 +84,27 @@ exports.getIntegrations = getIntegrations;
 async function publishIntegration(archivePath) {
     const file = fs.readFileSync(archivePath);
     const blob = new Blob([file], { type: 'binary' });
-    return await integrations_platform_client_1.default.publishIntegration({ file: blob });
+    return await IntegrationsPlatform.publishIntegration({ file: blob });
 }
 exports.publishIntegration = publishIntegration;
 async function createIntegration(configuration) {
     // The creation of an integration is kept to its minimal required fields...
-    const integration = await integrations_platform_client_1.default.createIntegration({ name: configuration.name });
+    const integration = await IntegrationsPlatform.createIntegration({ name: configuration.name });
     // ... as all other non-required fields are updated here.
     return updateIntegration(integration.id, configuration);
 }
 exports.createIntegration = createIntegration;
 async function inviteUserToIntegration(integrationId, email) {
-    await integrations_platform_client_1.default.inviteUser(integrationId, { email });
+    await IntegrationsPlatform.inviteUser(integrationId, { email });
 }
 exports.inviteUserToIntegration = inviteUserToIntegration;
 async function getIntegrationEvents(integrationId, options = {}) {
-    const { data: events } = await integrations_platform_client_1.default.getIntegrationEvents(integrationId, options);
+    const { data: events } = await IntegrationsPlatform.getIntegrationEvents(integrationId, options);
     return events;
 }
 exports.getIntegrationEvents = getIntegrationEvents;
 async function updateIntegration(integrationId, configuration) {
-    const current = await integrations_platform_client_1.default.getIntegrationById(integrationId);
+    const current = await IntegrationsPlatform.getIntegrationById(integrationId);
     // Create authorizations.
     const authorizationsToCreate = configuration.authorizations
         ?.filter(configAuthorization => !current.authorizations.some(platformAuthorization => platformAuthorization.name === configAuthorization.name))
@@ -141,7 +141,7 @@ async function updateIntegration(integrationId, configuration) {
         };
         return authorizationToUpdate;
     });
-    return await integrations_platform_client_1.default.updateIntegration(current.id, {
+    return await IntegrationsPlatform.updateIntegration(current.id, {
         baseUrl: configuration.baseUrl,
         graphRelativeUrl: configuration.graphRelativeUrl ?? '/',
         credentialAccountRelativeUrl: configuration.credentialAccountRelativeUrl ?? '/me',
@@ -156,6 +156,6 @@ async function updateIntegration(integrationId, configuration) {
 }
 exports.updateIntegration = updateIntegration;
 async function getCredential(credentialId) {
-    return integrations_platform_client_1.default.getCredentialById(credentialId);
+    return IntegrationsPlatform.getCredentialById(credentialId);
 }
 exports.getCredential = getCredential;

package/dist/src/services/integrationsPlatformClient.d.ts

@@ -0,0 +1,502 @@
+/**
+ * Integrations Platform API
+ * 0.1.0
+ * DO NOT MODIFY - This file has been generated using oazapfts.
+ * See https://www.npmjs.com/package/oazapfts
+ */
+import * as Oazapfts from '@oazapfts/runtime';
+export declare const defaults: Oazapfts.Defaults<Oazapfts.CustomHeaders>;
+export declare const servers: {
+    local: string;
+    staging: string;
+    production: string;
+};
+export type Pagination = {
+    /** The total number of results. */
+    total: number;
+};
+export type Base = {
+    createdAt: string;
+    updatedAt: string;
+    archivedAt: string | null;
+};
+export type IntegrationSummary = Base & {
+    /** The id of the integration. */
+    id: number;
+    /** The name of the integration. */
+    name: string;
+    /** The base URL where the integration is located. */
+    baseUrl: string | null;
+    /** The relative URL (to the baseUrl) where the graph of items of the integration is located. */
+    graphRelativeUrl: string;
+    /** The relative URL (to the baseUrl) to fetch the current integration's authenticated user. */
+    credentialAccountRelativeUrl: string;
+    /** The relative URL (to the baseUrl) to parse a webhook payload. */
+    webhookParsingRelativeUrl?: string | null;
+    /** The relative URL (to the baseUrl) to operate on webhook subscriptions. */
+    webhookSubscriptionsRelativeUrl?: string | null;
+    /** The relative URL (to the baseUrl) to acknowledge a webhook reception. */
+    webhookAcknowledgeRelativeUrl?: string | null;
+    /** The visibility of the integration. */
+    visibility: 'private' | 'public';
+    /** The list of organization ids for which this integration is visibile. */
+    unitoOrganizationIds: string[];
+    /** The UI-related information of the integration. */
+    ui: {
+        /** The name of the integration, as it should be displayed in a UI. */
+        displayName: string;
+        /** The logo of the integration, in SVG format. */
+        logo: string | null;
+    };
+    /** The encrypted secrets of the integration. */
+    secrets?: {
+        [key: string]: string;
+    };
+    /** The date at which the integration has been disabled */
+    disabledAt?: string | null;
+};
+export type Error = {
+    /** The message of the error. */
+    message: string;
+    /** The details of the error. */
+    details?: {
+        [key: string]: any;
+    };
+    /** The stack trace of the error. */
+    stack?: string[];
+};
+export type AuthorizationMethod = 'custom' | 'oauth2';
+export type AuthorizationGrantType = 'authorization_code' | 'password' | 'client_credentials';
+export type AuthorizationScope = {
+    /** The name of the scope. */
+    name: string;
+    /** Message to the end-user to explain the usage of the scope by Unito. */
+    help?: string;
+};
+export type AuthorizationOAuth2ContentType = 'application/x-www-form-urlencoded' | 'application/json';
+export type AuthorizationOAuth2RequestParameters = {
+    /** Extra information to include in the HTTP request headers. */
+    header?: {
+        [key: string]: string | number | boolean;
+    };
+    /** Extra information to include in the HTTP request body. */
+    body?: {
+        [key: string]: string | number | boolean;
+    };
+};
+export type AuthorizationOAuth2 = {
+    /** The Client Secret obtained from the provider. */
+    clientSecret?: string;
+    /** The Client Id obtained from the provider. */
+    clientId?: string;
+    /** The URL to grant or deny access to the user account. */
+    authorizationUrl?: string;
+    /** The URL to obtain or refresh an access token. */
+    tokenUrl: string;
+    grantType: AuthorizationGrantType;
+    scopes: AuthorizationScope[];
+    requestContentType: AuthorizationOAuth2ContentType;
+    responseContentType: AuthorizationOAuth2ContentType;
+    refreshRequestParameters?: AuthorizationOAuth2RequestParameters;
+    tokenRequestParameters?: AuthorizationOAuth2RequestParameters;
+} | null;
+export type AuthorizationVariables = {
+    [key: string]: {
+        type: 'boolean' | 'number' | 'password' | 'string' | 'text';
+        format?: 'uri' | 'email';
+        pattern?: string;
+        label?: string;
+        required?: boolean;
+        placeholder?: string;
+        defaultValue?: string | number | boolean;
+        help?: string;
+        documentationUrl?: string;
+    };
+};
+export type Authorization = Base & {
+    id: number;
+    integrationId: number;
+    name: string;
+    method: AuthorizationMethod;
+    oauth2: AuthorizationOAuth2;
+    variables: AuthorizationVariables;
+    /** The Base64-encoded data URL of an <img> src content. For example: 'data:image/png;base64,<base64>' */
+    instructionsImage?: string | null;
+    /** A string representing a markdown document. */
+    instructionsMarkdown?: string | null;
+};
+export type Integration = IntegrationSummary & {
+    /** The authorizations of the integration. */
+    authorizations: Authorization[];
+    /** The ids of the developers of the integration. */
+    userIds: number[];
+};
+export type IntegrationEvent = {
+    /** The date at which the event took place. */
+    date: string;
+    /** The text of the event. */
+    text: string;
+    /** The tags associated with the event. */
+    tags: string[];
+    /** The title of the event. */
+    title: string;
+};
+export type Credential = Base & {
+    /** The id of the credential. */
+    id: number;
+    /** The id of the integration. */
+    integrationId: number;
+    /** The name of the integration. */
+    integrationName: string;
+    /** The id of the authorization. */
+    authorizationId: number;
+    /** The scope of the credential. */
+    scope: 'development' | 'compliance' | 'production' | 'service';
+    /** The id of the Unito User for which this credential belongs to. */
+    unitoUserId: string | null;
+    /** The payload of the credential, which conforms to the schema (ex. variables) of the authorization. */
+    payload: {
+        [key: string]: any;
+    };
+    /** The partition used to divide data into different buckets. */
+    partitionKey?: string | null;
+};
+export type CredentialAccount = {
+    /** The native id of the provider account. */
+    id: string;
+    /** The display name of the provider account. */
+    displayName: string;
+    /** The emails associated with the provider account. */
+    emails: string[];
+    /** The partition used to divide data into different buckets. */
+    partition?: string;
+};
+export type UserRole = 'unitoAdministrator' | 'unitoService' | 'developer';
+export type UserSummary = Base & {
+    /** The id of the user. */
+    id: number;
+    /** The email of the user. */
+    email: string;
+    /** The ID of the organization which will have access to integrations created by this user. */
+    defaultUnitoOrganizationId: string | null;
+    /** The date & time at which the user accepted the terms & conditions of the SDK. */
+    termsAcceptedAt: string | null;
+    role: UserRole;
+};
+export type User = UserSummary & {
+    /** The API key of the user. */
+    apiKey: string;
+};
+/**
+ * Get all the integrations
+ */
+export declare function getIntegrations({ pagination, unitoOrganizationId, search, }?: {
+    pagination?: {
+        /** Number of 'first results' to skip */
+        offset?: number;
+        /** Maximum number of results after the offset */
+        limit?: number;
+    };
+    unitoOrganizationId?: string;
+    search?: string;
+}, opts?: Oazapfts.RequestOpts): Promise<Pagination & {
+    /** The integrations. */
+    data: IntegrationSummary[];
+}>;
+/**
+ * Create an integration
+ */
+export declare function createIntegration(body?: {
+    name: string;
+    baseUrl?: string | null;
+    graphRelativeUrl?: string | null;
+    credentialAccountRelativeUrl?: string | null;
+    webhookParsingRelativeUrl?: string | null;
+    webhookSubscriptionsRelativeUrl?: string | null;
+    webhookAcknowledgeRelativeUrl?: string | null;
+}, opts?: Oazapfts.RequestOpts): Promise<Integration>;
+/**
+ * Publish an integration
+ */
+export declare function publishIntegration(body?: {
+    /** The archive of the integration, including the .unito.json file. */
+    file: Blob;
+}, opts?: Oazapfts.RequestOpts): Promise<Integration>;
+/**
+ * Find an integration by exact name
+ */
+export declare function getIntegrationByName(integrationName: string, opts?: Oazapfts.RequestOpts): Promise<Integration>;
+/**
+ * Invite a user to an integration
+ */
+export declare function inviteUser(integrationId: number, body?: {
+    email?: string;
+}, opts?: Oazapfts.RequestOpts): Promise<unknown>;
+/**
+ * Invite a unito organization to an integration
+ */
+export declare function inviteOrganization(integrationId: number, body?: {
+    unitoOrganizationId?: string;
+}, opts?: Oazapfts.RequestOpts): Promise<Integration>;
+/**
+ * Get an integration
+ */
+export declare function getIntegrationById(integrationId: number, opts?: Oazapfts.RequestOpts): Promise<Integration>;
+/**
+ * Update an integration
+ */
+export declare function updateIntegration(integrationId: number, body?: {
+    baseUrl?: string | null;
+    graphRelativeUrl?: string | null;
+    credentialAccountRelativeUrl?: string | null;
+    webhookParsingRelativeUrl?: string | null;
+    webhookSubscriptionsRelativeUrl?: string | null;
+    webhookAcknowledgeRelativeUrl?: string | null;
+    authorizations?: {
+        id?: number;
+        name: string;
+        method: AuthorizationMethod;
+        oauth2?: AuthorizationOAuth2;
+        variables?: AuthorizationVariables;
+        archived?: boolean;
+    }[];
+    userIds?: number[];
+    archived?: boolean;
+    disabled?: boolean;
+    ui?: {
+        displayName?: string | null;
+        logo?: string | null;
+    };
+    visibility?: 'private' | 'public';
+    unitoOrganizationIds?: string[];
+    /** The encrypted secrets of the integration. */
+    secrets?: {
+        [key: string]: string;
+    };
+}, opts?: Oazapfts.RequestOpts): Promise<Integration>;
+/**
+ * Delete an integration
+ */
+export declare function deleteIntegration(integrationId: number, name: string, opts?: Oazapfts.RequestOpts): Promise<unknown>;
+/**
+ * Get the events associated with this integration.
+ */
+export declare function getIntegrationEvents(integrationId: number, { search, $from, limit, }?: {
+    search?: string;
+    $from?: number;
+    limit?: number;
+}, opts?: Oazapfts.RequestOpts): Promise<Pagination & {
+    /** The integration events. */
+    data: IntegrationEvent[];
+}>;
+/**
+ * Get the logo of the integration, in SVG format.
+ */
+export declare function getIntegrationLogo(integrationName: string, opts?: Oazapfts.RequestOpts): Promise<Blob>;
+/**
+ * Get all the credentials
+ */
+export declare function getCredentials({ pagination, filters, }?: {
+    pagination?: {
+        /** Number of 'first results' to skip */
+        offset?: number;
+        /** Maximum number of results after the offset */
+        limit?: number;
+    };
+    filters?: {
+        /** The authorization id of the credential. */
+        authorizationId?: number;
+        /** The integration id of the credential. */
+        integrationId?: number;
+        /** List of credential ids. */
+        id?: number[];
+        /** The scope of the credential. */
+        credentialScope?: 'development' | 'compliance' | 'production' | 'service';
+        /** The id of the Unito User for which this credential belongs to. */
+        unitoUserId?: string;
+        /** The id of the credential account for which this credential belongs to. */
+        credentialAccountId?: string;
+    };
+}, opts?: Oazapfts.RequestOpts): Promise<Pagination & {
+    /** The credentials. */
+    data: Credential[];
+}>;
+/**
+ * Create a credential
+ */
+export declare function createCredential(body?: {
+    authorizationId: number;
+    scope?: 'development' | 'compliance' | 'production' | 'service';
+    payload: {
+        [key: string]: any;
+    };
+    unitoUserId?: string;
+    credentialAccountId?: string;
+}, opts?: Oazapfts.RequestOpts): Promise<Credential>;
+/**
+ * Get a credential
+ */
+export declare function getCredentialById(credentialId: number, opts?: Oazapfts.RequestOpts): Promise<Credential>;
+/**
+ * Update a credential
+ */
+export declare function updateCredential(credentialId: number, body?: {
+    payload?: {
+        [key: string]: any;
+    };
+    scope?: 'development' | 'compliance' | 'production' | 'service';
+    archived?: boolean;
+    unitoUserId?: string;
+    credentialAccountId?: string;
+}, opts?: Oazapfts.RequestOpts): Promise<Credential>;
+/**
+ * Delete a credential
+ */
+export declare function deleteCredential(credentialId: number, opts?: Oazapfts.RequestOpts): Promise<unknown>;
+/**
+ * Returns the credentialAccount either from the integration's /me endpoint, if available, or the credential's latestCredentialAccount
+ */
+export declare function getCredentialAccount(xUnitoCredentialId: string, { xUnitoCorrelationId, xUnitoAdditionalLoggingContext, }?: {
+    xUnitoCorrelationId?: string;
+    xUnitoAdditionalLoggingContext?: string;
+}, opts?: Oazapfts.RequestOpts): Promise<CredentialAccount>;
+/**
+ * Used by the frontend to send analytics data
+ */
+export declare function postTrack(body: {
+    jwtToken: string;
+    event: 'AUTH_START' | 'AUTH_SUBMIT' | 'AUTH_ACTION' | 'AUTH_BLOCKED' | 'AUTH_CHOOSE_CONNECTION_START' | 'AUTH_CHOOSE_CONNECTION_SUBMIT';
+    payload?: {
+        [key: string]: any;
+    };
+}, opts?: Oazapfts.RequestOpts): Promise<unknown>;
+/**
+ * Encrypt data
+ */
+export declare function encryptData(body: {
+    data: string;
+    integrationName: string;
+    sensitive?: boolean;
+}, opts?: Oazapfts.RequestOpts): Promise<{
+    encryptedData: string;
+}>;
+/**
+ * Decrypt data
+ */
+export declare function decryptData(body: {
+    data: string;
+    integrationName: string;
+}, opts?: Oazapfts.RequestOpts): Promise<{
+    decryptedData: string;
+}>;
+/**
+ * Decrypt and encrypt data
+ */
+export declare function reencryptData(body: {
+    encryptedData: string;
+    integrationName: string;
+    newIntegrationName: string;
+}, opts?: Oazapfts.RequestOpts): Promise<{
+    encryptedData: string;
+}>;
+/**
+ * Get my profile
+ */
+export declare function getProfile(opts?: Oazapfts.RequestOpts): Promise<User>;
+/**
+ * Update my profile
+ */
+export declare function updateProfile(body?: {
+    termsAccepted?: boolean;
+}, opts?: Oazapfts.RequestOpts): Promise<User>;
+/**
+ * Call an integration's me
+ */
+export declare function getProxyMe(xUnitoCredentialId: string, { xUnitoCorrelationId, xUnitoAdditionalLoggingContext, }?: {
+    xUnitoCorrelationId?: string;
+    xUnitoAdditionalLoggingContext?: string;
+}, opts?: Oazapfts.RequestOpts): Promise<CredentialAccount>;
+/**
+ * Update a webhook subscription
+ */
+export declare function updateWebhookSubscription(xUnitoCredentialId: string, body: {
+    itemPath: string;
+    targetUrl: string;
+    action: 'start' | 'stop';
+}, { xUnitoCorrelationId, xUnitoAdditionalLoggingContext, }?: {
+    xUnitoCorrelationId?: string;
+    xUnitoAdditionalLoggingContext?: string;
+}, opts?: Oazapfts.RequestOpts): Promise<unknown>;
+/**
+ * Call an integration's graph
+ */
+export declare function getProxyGraph(xUnitoCredentialId: string, path: string, { xUnitoCorrelationId, xUnitoAdditionalLoggingContext, }?: {
+    xUnitoCorrelationId?: string;
+    xUnitoAdditionalLoggingContext?: string;
+}, opts?: Oazapfts.RequestOpts): Promise<any>;
+/**
+ * Call an integration's graph
+ */
+export declare function patchProxyGraph(xUnitoCredentialId: string, path: string, body?: object, { xUnitoCorrelationId, xUnitoAdditionalLoggingContext, }?: {
+    xUnitoCorrelationId?: string;
+    xUnitoAdditionalLoggingContext?: string;
+}, opts?: Oazapfts.RequestOpts): Promise<any>;
+/**
+ * Call an integration's graph
+ */
+export declare function postProxyGraph(xUnitoCredentialId: string, path: string, body?: object, { xUnitoCorrelationId, xUnitoAdditionalLoggingContext, }?: {
+    xUnitoCorrelationId?: string;
+    xUnitoAdditionalLoggingContext?: string;
+}, opts?: Oazapfts.RequestOpts): Promise<any>;
+/**
+ * Call an integration's graph
+ */
+export declare function deleteProxyGraph(xUnitoCredentialId: string, path: string, { xUnitoCorrelationId, xUnitoAdditionalLoggingContext, }?: {
+    xUnitoCorrelationId?: string;
+    xUnitoAdditionalLoggingContext?: string;
+}, opts?: Oazapfts.RequestOpts): Promise<any>;
+/**
+ * Get all the users
+ */
+export declare function getUsers({ pagination, }?: {
+    pagination?: {
+        /** Number of 'first results' to skip */
+        offset?: number;
+        /** Maximum number of results after the offset */
+        limit?: number;
+    };
+}, opts?: Oazapfts.RequestOpts): Promise<Pagination & {
+    /** The users. */
+    data: UserSummary[];
+}>;
+/**
+ * Create a user
+ */
+export declare function createUser(body: {
+    email: string;
+    defaultUnitoOrganizationId?: string | null;
+    role: UserRole;
+}, opts?: Oazapfts.RequestOpts): Promise<User>;
+/**
+ * Get a user
+ */
+export declare function getUserById(userId: number, opts?: Oazapfts.RequestOpts): Promise<User>;
+/**
+ * Update a user
+ */
+export declare function updateUser(userId: number, body: {
+    email?: string;
+    role?: UserRole;
+    archived?: boolean;
+    defaultUnitoOrganizationId?: string | null;
+}, opts?: Oazapfts.RequestOpts): Promise<User>;
+/**
+ * Regenerate the api key of a user
+ */
+export declare function regenerateApiKey(userId: number, opts?: Oazapfts.RequestOpts): Promise<User>;
+/**
+ * Get a user by its email address
+ */
+export declare function getUserByEmail(email: string, opts?: Oazapfts.RequestOpts): Promise<User>;
+import { HttpError } from '@oazapfts/runtime';
+export { HttpError };

package/dist/src/services/integrationsPlatformClient.js

@@ -0,0 +1,435 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpError = exports.getUserByEmail = exports.regenerateApiKey = exports.updateUser = exports.getUserById = exports.createUser = exports.getUsers = exports.deleteProxyGraph = exports.postProxyGraph = exports.patchProxyGraph = exports.getProxyGraph = exports.updateWebhookSubscription = exports.getProxyMe = exports.updateProfile = exports.getProfile = exports.reencryptData = exports.decryptData = exports.encryptData = exports.postTrack = exports.getCredentialAccount = exports.deleteCredential = exports.updateCredential = exports.getCredentialById = exports.createCredential = exports.getCredentials = exports.getIntegrationLogo = exports.getIntegrationEvents = exports.deleteIntegration = exports.updateIntegration = exports.getIntegrationById = exports.inviteOrganization = exports.inviteUser = exports.getIntegrationByName = exports.publishIntegration = exports.createIntegration = exports.getIntegrations = exports.servers = exports.defaults = void 0;
+const tslib_1 = require("tslib");
+/**
+ * Integrations Platform API
+ * 0.1.0
+ * DO NOT MODIFY - This file has been generated using oazapfts.
+ * See https://www.npmjs.com/package/oazapfts
+ */
+const Oazapfts = tslib_1.__importStar(require("@oazapfts/runtime"));
+const QS = tslib_1.__importStar(require("@oazapfts/runtime/query"));
+exports.defaults = {
+    headers: {},
+    baseUrl: 'http://localhost:9000',
+};
+const oazapfts = Oazapfts.runtime(exports.defaults);
+exports.servers = {
+    local: 'http://localhost:9000',
+    staging: 'https://staging-integrations-platform.unito.io',
+    production: 'https://integrations-platform.unito.io',
+};
+/**
+ * Get all the integrations
+ */
+function getIntegrations({ pagination, unitoOrganizationId, search, } = {}, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/integrations${QS.query(QS.explode({
+        pagination,
+        unitoOrganizationId,
+        search,
+    }))}`, {
+        ...opts,
+    }));
+}
+exports.getIntegrations = getIntegrations;
+/**
+ * Create an integration
+ */
+function createIntegration(body, opts) {
+    return oazapfts.ok(oazapfts.fetchJson('/integrations', oazapfts.json({
+        ...opts,
+        method: 'POST',
+        body,
+    })));
+}
+exports.createIntegration = createIntegration;
+/**
+ * Publish an integration
+ */
+function publishIntegration(body, opts) {
+    return oazapfts.ok(oazapfts.fetchJson('/integrations/publish', oazapfts.multipart({
+        ...opts,
+        method: 'POST',
+        body,
+    })));
+}
+exports.publishIntegration = publishIntegration;
+/**
+ * Find an integration by exact name
+ */
+function getIntegrationByName(integrationName, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/integrations/find/${encodeURIComponent(integrationName)}`, {
+        ...opts,
+    }));
+}
+exports.getIntegrationByName = getIntegrationByName;
+/**
+ * Invite a user to an integration
+ */
+function inviteUser(integrationId, body, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/integrations/${encodeURIComponent(integrationId)}/users/invite`, oazapfts.json({
+        ...opts,
+        method: 'POST',
+        body,
+    })));
+}
+exports.inviteUser = inviteUser;
+/**
+ * Invite a unito organization to an integration
+ */
+function inviteOrganization(integrationId, body, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/integrations/${encodeURIComponent(integrationId)}/organizations/invite`, oazapfts.json({
+        ...opts,
+        method: 'POST',
+        body,
+    })));
+}
+exports.inviteOrganization = inviteOrganization;
+/**
+ * Get an integration
+ */
+function getIntegrationById(integrationId, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/integrations/${encodeURIComponent(integrationId)}`, {
+        ...opts,
+    }));
+}
+exports.getIntegrationById = getIntegrationById;
+/**
+ * Update an integration
+ */
+function updateIntegration(integrationId, body, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/integrations/${encodeURIComponent(integrationId)}`, oazapfts.json({
+        ...opts,
+        method: 'PATCH',
+        body,
+    })));
+}
+exports.updateIntegration = updateIntegration;
+/**
+ * Delete an integration
+ */
+function deleteIntegration(integrationId, name, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/integrations/${encodeURIComponent(integrationId)}${QS.query(QS.explode({
+        name,
+    }))}`, {
+        ...opts,
+        method: 'DELETE',
+    }));
+}
+exports.deleteIntegration = deleteIntegration;
+/**
+ * Get the events associated with this integration.
+ */
+function getIntegrationEvents(integrationId, { search, $from, limit, } = {}, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/integrations/${encodeURIComponent(integrationId)}/events${QS.query(QS.explode({
+        search,
+        from: $from,
+        limit,
+    }))}`, {
+        ...opts,
+    }));
+}
+exports.getIntegrationEvents = getIntegrationEvents;
+/**
+ * Get the logo of the integration, in SVG format.
+ */
+function getIntegrationLogo(integrationName, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/public/${encodeURIComponent(integrationName)}/logo.svg`, {
+        ...opts,
+    }));
+}
+exports.getIntegrationLogo = getIntegrationLogo;
+/**
+ * Get all the credentials
+ */
+function getCredentials({ pagination, filters, } = {}, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/credentials${QS.query(QS.explode({
+        pagination,
+        filters,
+    }))}`, {
+        ...opts,
+    }));
+}
+exports.getCredentials = getCredentials;
+/**
+ * Create a credential
+ */
+function createCredential(body, opts) {
+    return oazapfts.ok(oazapfts.fetchJson('/credentials', oazapfts.json({
+        ...opts,
+        method: 'POST',
+        body,
+    })));
+}
+exports.createCredential = createCredential;
+/**
+ * Get a credential
+ */
+function getCredentialById(credentialId, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/credentials/${encodeURIComponent(credentialId)}`, {
+        ...opts,
+    }));
+}
+exports.getCredentialById = getCredentialById;
+/**
+ * Update a credential
+ */
+function updateCredential(credentialId, body, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/credentials/${encodeURIComponent(credentialId)}`, oazapfts.json({
+        ...opts,
+        method: 'PATCH',
+        body,
+    })));
+}
+exports.updateCredential = updateCredential;
+/**
+ * Delete a credential
+ */
+function deleteCredential(credentialId, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/credentials/${encodeURIComponent(credentialId)}`, {
+        ...opts,
+        method: 'DELETE',
+    }));
+}
+exports.deleteCredential = deleteCredential;
+/**
+ * Returns the credentialAccount either from the integration's /me endpoint, if available, or the credential's latestCredentialAccount
+ */
+function getCredentialAccount(xUnitoCredentialId, { xUnitoCorrelationId, xUnitoAdditionalLoggingContext, } = {}, opts) {
+    return oazapfts.ok(oazapfts.fetchJson('/credentialAccount', {
+        ...opts,
+        headers: oazapfts.mergeHeaders(opts?.headers, {
+            'X-Unito-Credential-Id': xUnitoCredentialId,
+            'X-Unito-Correlation-Id': xUnitoCorrelationId,
+            'X-Unito-Additional-Logging-Context': xUnitoAdditionalLoggingContext,
+        }),
+    }));
+}
+exports.getCredentialAccount = getCredentialAccount;
+/**
+ * Used by the frontend to send analytics data
+ */
+function postTrack(body, opts) {
+    return oazapfts.ok(oazapfts.fetchJson('/track', oazapfts.json({
+        ...opts,
+        method: 'POST',
+        body,
+    })));
+}
+exports.postTrack = postTrack;
+/**
+ * Encrypt data
+ */
+function encryptData(body, opts) {
+    return oazapfts.ok(oazapfts.fetchJson('/encryptions/encrypt', oazapfts.json({
+        ...opts,
+        method: 'POST',
+        body,
+    })));
+}
+exports.encryptData = encryptData;
+/**
+ * Decrypt data
+ */
+function decryptData(body, opts) {
+    return oazapfts.ok(oazapfts.fetchJson('/encryptions/decrypt', oazapfts.json({
+        ...opts,
+        method: 'POST',
+        body,
+    })));
+}
+exports.decryptData = decryptData;
+/**
+ * Decrypt and encrypt data
+ */
+function reencryptData(body, opts) {
+    return oazapfts.ok(oazapfts.fetchJson('/encryptions/reencrypt', oazapfts.json({
+        ...opts,
+        method: 'POST',
+        body,
+    })));
+}
+exports.reencryptData = reencryptData;
+/**
+ * Get my profile
+ */
+function getProfile(opts) {
+    return oazapfts.ok(oazapfts.fetchJson('/profile', {
+        ...opts,
+    }));
+}
+exports.getProfile = getProfile;
+/**
+ * Update my profile
+ */
+function updateProfile(body, opts) {
+    return oazapfts.ok(oazapfts.fetchJson('/profile', oazapfts.json({
+        ...opts,
+        method: 'PATCH',
+        body,
+    })));
+}
+exports.updateProfile = updateProfile;
+/**
+ * Call an integration's me
+ */
+function getProxyMe(xUnitoCredentialId, { xUnitoCorrelationId, xUnitoAdditionalLoggingContext, } = {}, opts) {
+    return oazapfts.ok(oazapfts.fetchJson('/proxy/me', {
+        ...opts,
+        headers: oazapfts.mergeHeaders(opts?.headers, {
+            'X-Unito-Credential-Id': xUnitoCredentialId,
+            'X-Unito-Correlation-Id': xUnitoCorrelationId,
+            'X-Unito-Additional-Logging-Context': xUnitoAdditionalLoggingContext,
+        }),
+    }));
+}
+exports.getProxyMe = getProxyMe;
+/**
+ * Update a webhook subscription
+ */
+function updateWebhookSubscription(xUnitoCredentialId, body, { xUnitoCorrelationId, xUnitoAdditionalLoggingContext, } = {}, opts) {
+    return oazapfts.ok(oazapfts.fetchJson('/proxy/webhooks/subscriptions', oazapfts.json({
+        ...opts,
+        method: 'PUT',
+        body,
+        headers: oazapfts.mergeHeaders(opts?.headers, {
+            'X-Unito-Credential-Id': xUnitoCredentialId,
+            'X-Unito-Correlation-Id': xUnitoCorrelationId,
+            'X-Unito-Additional-Logging-Context': xUnitoAdditionalLoggingContext,
+        }),
+    })));
+}
+exports.updateWebhookSubscription = updateWebhookSubscription;
+/**
+ * Call an integration's graph
+ */
+function getProxyGraph(xUnitoCredentialId, path, { xUnitoCorrelationId, xUnitoAdditionalLoggingContext, } = {}, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/proxy/graph${QS.query(QS.explode({
+        path,
+    }))}`, {
+        ...opts,
+        headers: oazapfts.mergeHeaders(opts?.headers, {
+            'X-Unito-Credential-Id': xUnitoCredentialId,
+            'X-Unito-Correlation-Id': xUnitoCorrelationId,
+            'X-Unito-Additional-Logging-Context': xUnitoAdditionalLoggingContext,
+        }),
+    }));
+}
+exports.getProxyGraph = getProxyGraph;
+/**
+ * Call an integration's graph
+ */
+function patchProxyGraph(xUnitoCredentialId, path, body, { xUnitoCorrelationId, xUnitoAdditionalLoggingContext, } = {}, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/proxy/graph${QS.query(QS.explode({
+        path,
+    }))}`, oazapfts.json({
+        ...opts,
+        method: 'PATCH',
+        body,
+        headers: oazapfts.mergeHeaders(opts?.headers, {
+            'X-Unito-Credential-Id': xUnitoCredentialId,
+            'X-Unito-Correlation-Id': xUnitoCorrelationId,
+            'X-Unito-Additional-Logging-Context': xUnitoAdditionalLoggingContext,
+        }),
+    })));
+}
+exports.patchProxyGraph = patchProxyGraph;
+/**
+ * Call an integration's graph
+ */
+function postProxyGraph(xUnitoCredentialId, path, body, { xUnitoCorrelationId, xUnitoAdditionalLoggingContext, } = {}, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/proxy/graph${QS.query(QS.explode({
+        path,
+    }))}`, oazapfts.json({
+        ...opts,
+        method: 'POST',
+        body,
+        headers: oazapfts.mergeHeaders(opts?.headers, {
+            'X-Unito-Credential-Id': xUnitoCredentialId,
+            'X-Unito-Correlation-Id': xUnitoCorrelationId,
+            'X-Unito-Additional-Logging-Context': xUnitoAdditionalLoggingContext,
+        }),
+    })));
+}
+exports.postProxyGraph = postProxyGraph;
+/**
+ * Call an integration's graph
+ */
+function deleteProxyGraph(xUnitoCredentialId, path, { xUnitoCorrelationId, xUnitoAdditionalLoggingContext, } = {}, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/proxy/graph${QS.query(QS.explode({
+        path,
+    }))}`, {
+        ...opts,
+        method: 'DELETE',
+        headers: oazapfts.mergeHeaders(opts?.headers, {
+            'X-Unito-Credential-Id': xUnitoCredentialId,
+            'X-Unito-Correlation-Id': xUnitoCorrelationId,
+            'X-Unito-Additional-Logging-Context': xUnitoAdditionalLoggingContext,
+        }),
+    }));
+}
+exports.deleteProxyGraph = deleteProxyGraph;
+/**
+ * Get all the users
+ */
+function getUsers({ pagination, } = {}, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/users${QS.query(QS.explode({
+        pagination,
+    }))}`, {
+        ...opts,
+    }));
+}
+exports.getUsers = getUsers;
+/**
+ * Create a user
+ */
+function createUser(body, opts) {
+    return oazapfts.ok(oazapfts.fetchJson('/users', oazapfts.json({
+        ...opts,
+        method: 'POST',
+        body,
+    })));
+}
+exports.createUser = createUser;
+/**
+ * Get a user
+ */
+function getUserById(userId, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/users/${encodeURIComponent(userId)}`, {
+        ...opts,
+    }));
+}
+exports.getUserById = getUserById;
+/**
+ * Update a user
+ */
+function updateUser(userId, body, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/users/${encodeURIComponent(userId)}`, oazapfts.json({
+        ...opts,
+        method: 'PATCH',
+        body,
+    })));
+}
+exports.updateUser = updateUser;
+/**
+ * Regenerate the api key of a user
+ */
+function regenerateApiKey(userId, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/users/${encodeURIComponent(userId)}/apiKey`, {
+        ...opts,
+        method: 'POST',
+    }));
+}
+exports.regenerateApiKey = regenerateApiKey;
+/**
+ * Get a user by its email address
+ */
+function getUserByEmail(email, opts) {
+    return oazapfts.ok(oazapfts.fetchJson(`/users/find/${encodeURIComponent(email)}`, {
+        ...opts,
+    }));
+}
+exports.getUserByEmail = getUserByEmail;
+const runtime_1 = require("@oazapfts/runtime");
+Object.defineProperty(exports, "HttpError", { enumerable: true, get: function () { return runtime_1.HttpError; } });

package/dist/test/helpers/integrations.d.ts

@@ -21,6 +21,6 @@ export declare function generateIntegration(overrides?: Partial<IntegrationsPlat
         [key: string]: string;
     } | undefined;
     disabledAt?: string | null | undefined;
-    authorizations: import("@unito/integrations-platform-client/dist/src/api").Authorization[];
+    authorizations: import("../../src/services/integrationsPlatformClient").Authorization[];
     userIds: number[];
 };

package/dist/test/services/integrationsPlatform.test.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const strict_1 = tslib_1.__importDefault(require("node:assert/strict"));
 const sinon = tslib_1.__importStar(require("sinon"));
-const integrations_platform_client_1 = tslib_1.__importDefault(require("@unito/integrations-platform-client"));
+const IntegrationsPlatformClient = tslib_1.__importStar(require("../../src/services/integrationsPlatformClient"));
 const IntegrationsPlatform = tslib_1.__importStar(require("../../src/services/integrationsPlatform"));
 const globalConfiguration_1 = require("../../src/resources/globalConfiguration");
 const configurationTypes_1 = require("../../src/configurationTypes");
@@ -45,49 +45,49 @@ describe('integrations platform', function () {
     });
     it('environment', function () {
         IntegrationsPlatform.setEnvironment(globalConfiguration_1.Environment.Local);
-        strict_1.default.equal(integrations_platform_client_1.default.defaults.baseUrl, integrations_platform_client_1.default.servers.local);
+        strict_1.default.equal(IntegrationsPlatformClient.defaults.baseUrl, IntegrationsPlatformClient.servers.local);
         IntegrationsPlatform.setEnvironment(globalConfiguration_1.Environment.Production);
-        strict_1.default.equal(integrations_platform_client_1.default.defaults.baseUrl, integrations_platform_client_1.default.servers.production);
+        strict_1.default.equal(IntegrationsPlatformClient.defaults.baseUrl, IntegrationsPlatformClient.servers.production);
     });
     it('apiKey', function () {
         IntegrationsPlatform.setApiKey('foo');
         strict_1.default.equal(IntegrationsPlatform.getApiKey(), 'foo');
-        strict_1.default.deepEqual(integrations_platform_client_1.default.defaults.headers, {
+        strict_1.default.deepEqual(IntegrationsPlatformClient.defaults.headers, {
             Authorization: 'Bearer foo',
         });
         IntegrationsPlatform.setApiKey(undefined);
         strict_1.default.equal(IntegrationsPlatform.getApiKey(), undefined);
-        strict_1.default.deepEqual(integrations_platform_client_1.default.defaults.headers, {});
+        strict_1.default.deepEqual(IntegrationsPlatformClient.defaults.headers, {});
     });
     it('getProfile', async function () {
-        sinon.stub(integrations_platform_client_1.default, 'getProfile').resolves(user);
+        sinon.stub(IntegrationsPlatformClient, 'getProfile').resolves(user);
         strict_1.default.deepEqual(await IntegrationsPlatform.getProfile(), user);
     });
     it('getIntegration', async function () {
-        sinon.stub(integrations_platform_client_1.default, 'getIntegrationById').resolves(integration);
+        sinon.stub(IntegrationsPlatformClient, 'getIntegrationById').resolves(integration);
         strict_1.default.deepEqual(await IntegrationsPlatform.getIntegration(1), integration);
     });
     it('getIntegrationByName', async function () {
-        sinon.stub(integrations_platform_client_1.default, 'getIntegrationByName').resolves(integration);
+        sinon.stub(IntegrationsPlatformClient, 'getIntegrationByName').resolves(integration);
         strict_1.default.deepEqual(await IntegrationsPlatform.getIntegrationByName('foo'), integration);
     });
     it('getIntegrations', async function () {
-        sinon.stub(integrations_platform_client_1.default, 'getIntegrations').resolves({ total: 1, data: [integrationSummary] });
+        sinon.stub(IntegrationsPlatformClient, 'getIntegrations').resolves({ total: 1, data: [integrationSummary] });
         strict_1.default.deepEqual(await IntegrationsPlatform.getIntegrations(), [integrationSummary]);
     });
     it('createIntegration', async function () {
-        sinon.stub(integrations_platform_client_1.default, 'createIntegration').resolves(integration);
-        sinon.stub(integrations_platform_client_1.default, 'getIntegrationById').resolves(integration);
-        sinon.stub(integrations_platform_client_1.default, 'updateIntegration').resolves(integration);
+        sinon.stub(IntegrationsPlatformClient, 'createIntegration').resolves(integration);
+        sinon.stub(IntegrationsPlatformClient, 'getIntegrationById').resolves(integration);
+        sinon.stub(IntegrationsPlatformClient, 'updateIntegration').resolves(integration);
         strict_1.default.deepEqual(await IntegrationsPlatform.createIntegration({ name: 'foo' }), integration);
     });
     it('updateIntegration', async function () {
-        sinon.stub(integrations_platform_client_1.default, 'getIntegrationById').resolves(integration);
-        sinon.stub(integrations_platform_client_1.default, 'updateIntegration').resolves(integration);
+        sinon.stub(IntegrationsPlatformClient, 'getIntegrationById').resolves(integration);
+        sinon.stub(IntegrationsPlatformClient, 'updateIntegration').resolves(integration);
         strict_1.default.deepEqual(await IntegrationsPlatform.updateIntegration(1, { name: 'foo' }), integration);
     });
     it('updateIntegration - create / archive authorization', async function () {
-        sinon.stub(integrations_platform_client_1.default, 'getIntegrationById').resolves({
+        sinon.stub(IntegrationsPlatformClient, 'getIntegrationById').resolves({
             ...integration,
             authorizations: [
                 {
@@ -103,14 +103,14 @@ describe('integrations platform', function () {
                 },
             ],
         });
-        sinon.stub(integrations_platform_client_1.default, 'updateIntegration').resolves(integration);
+        sinon.stub(IntegrationsPlatformClient, 'updateIntegration').resolves(integration);
         strict_1.default.deepEqual(await IntegrationsPlatform.updateIntegration(1, {
             name: 'foo',
             authorizations: [{ name: 'bar', method: configurationTypes_1.Method.CUSTOM }],
         }), integration);
     });
     it('updateIntegration - update authorization', async function () {
-        sinon.stub(integrations_platform_client_1.default, 'getIntegrationById').resolves({
+        sinon.stub(IntegrationsPlatformClient, 'getIntegrationById').resolves({
             ...integration,
             authorizations: [
                 {
@@ -126,7 +126,7 @@ describe('integrations platform', function () {
                 },
             ],
         });
-        sinon.stub(integrations_platform_client_1.default, 'updateIntegration').resolves(integration);
+        sinon.stub(IntegrationsPlatformClient, 'updateIntegration').resolves(integration);
         strict_1.default.deepEqual(await IntegrationsPlatform.updateIntegration(1, { name: 'foo' }), integration);
         strict_1.default.deepEqual(await IntegrationsPlatform.updateIntegration(1, {
             name: 'foo',
@@ -134,8 +134,8 @@ describe('integrations platform', function () {
         }), integration);
     });
     it('updateIntegration - update secrets', async function () {
-        sinon.stub(integrations_platform_client_1.default, 'getIntegrationById').resolves({ ...integration });
-        const mockUpdateIntegration = sinon.stub(integrations_platform_client_1.default, 'updateIntegration');
+        sinon.stub(IntegrationsPlatformClient, 'getIntegrationById').resolves({ ...integration });
+        const mockUpdateIntegration = sinon.stub(IntegrationsPlatformClient, 'updateIntegration');
         const integrationId = 1;
         const configuration = {
             name: 'foo',
@@ -158,8 +158,8 @@ describe('integrations platform', function () {
         });
     });
     it('updateIntegration - unarchive', async function () {
-        sinon.stub(integrations_platform_client_1.default, 'getIntegrationById').resolves({ ...integration });
-        const mockUpdateIntegration = sinon.stub(integrations_platform_client_1.default, 'updateIntegration');
+        sinon.stub(IntegrationsPlatformClient, 'getIntegrationById').resolves({ ...integration });
+        const mockUpdateIntegration = sinon.stub(IntegrationsPlatformClient, 'updateIntegration');
         const integrationId = 1;
         const archived = false;
         const configuration = {
@@ -183,7 +183,7 @@ describe('integrations platform', function () {
         });
     });
     it('encryptData', async function () {
-        sinon.stub(integrations_platform_client_1.default, 'encryptData').resolves({ encryptedData: 'encryptedFoo' });
+        sinon.stub(IntegrationsPlatformClient, 'encryptData').resolves({ encryptedData: 'encryptedFoo' });
         strict_1.default.deepEqual(await IntegrationsPlatform.encryptData('mySuperIntegration', 'foo', false), {
             encryptedData: 'encryptedFoo',
         });

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.60.1",
+  "version": "0.60.2",
   "commands": {
     "activity": {
       "id": "activity",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unito/integration-cli",
-  "version": "0.60.1",
+  "version": "0.60.2",
   "description": "Integration CLI",
   "bin": {
     "integration-cli": "./bin/run"
@@ -36,8 +36,8 @@
   ],
   "dependencies": {
     "@oclif/core": "3.x",
-    "@unito/integration-debugger": "0.25.1",
-    "@unito/integrations-platform-client": "0.48.2",
+    "@unito/integration-debugger": "0.26.0",
+    "@oazapfts/runtime": "1.x",
     "ajv": "8.x",
     "ajv-formats": "2.x",
     "better-ajv-errors": "1.x",