Class IntegrationLevelFlowAccessor

client

integrationSelector

getUniqueIdentifier

• getUniqueIdentifier(): string

  Returns string

get

• get(): Promise<
      {
          integration?: {
              logoUri: string;
              connectorId?: string;
              connectorVersion?: string;
              oAuthCallbackUri?: string;
              parameters?: any;
              archivedAt?: string;
              hasMissingParameters?: boolean;
              hasDocumentation?: boolean;
              hasOperations?: boolean;
              operationsCount?: number;
              hasData?: boolean;
              dataCollectionsCount?: number;
              hasEvents?: boolean;
              eventsCount?: number;
              hasGlobalWebhooks?: boolean;
              hasUdm?: boolean;
              isTest?: boolean;
              appUuid?: string;
              isDeactivated?: boolean;
              authType?: | "proxy"
              | "integration-app-token"
              | "membrane-token"
              | "oauth2"
              | "oauth1"
              | "client-credentials";
              id: string;
              key?: string;
              uuid?: string;
              description?: string;
              meta?: Record<string, any>;
              name: string;
              state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
              errors?: ErrorDataSchema[];
              revision?: string;
              createdAt?: string;
              updatedAt?: string;
          };
          appliedToIntegrations?: {
              element: {
                  id: string;
                  integrationId?: string;
                  isCustomized?: boolean;
                  universalFlowId?: string;
              };
              integration: {
                  logoUri: string;
                  connectorId?: string;
                  connectorVersion?: string;
                  oAuthCallbackUri?: string;
                  parameters?: any;
                  archivedAt?: string;
                  hasMissingParameters?: boolean;
                  hasDocumentation?: boolean;
                  hasOperations?: boolean;
                  operationsCount?: number;
                  hasData?: boolean;
                  dataCollectionsCount?: number;
                  hasEvents?: boolean;
                  eventsCount?: number;
                  hasGlobalWebhooks?: boolean;
                  hasUdm?: boolean;
                  isTest?: boolean;
                  appUuid?: string;
                  isDeactivated?: boolean;
                  authType?: | "proxy"
                  | "integration-app-token"
                  | "membrane-token"
                  | "oauth2"
                  | "oauth1"
                  | "client-credentials";
                  id: string;
                  key?: string;
                  uuid?: string;
                  description?: string;
                  meta?: Record<string, any>;
                  name: string;
                  state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
                  errors?: ErrorDataSchema[];
                  revision?: string;
                  createdAt?: string;
                  updatedAt?: string;
              };
          }[];
          dependencies?: any[];
          integrationId?: string;
          universalFlowId?: string;
          parametersSchema?: DataSchema;
          nodes?: Record<
              string,
              {
                  type?: string;
                  version?: number;
                  name?: string;
                  description?: string;
                  config?: any;
                  concurrency?: number;
                  onError?: "continue"
                  | "stop";
                  ui?: any;
                  inputSchema?: any;
                  outputSchema?: any;
                  outputExample?: any;
                  links?: { key?: string; filter?: any; name?: string }[];
                  isCustomized?: boolean;
              },
          >;
          autoCreateInstances?: boolean;
          universalFlowRevision?: string;
          id: string;
          key?: string;
          uuid?: string;
          description?: string;
          meta?: Record<string, any>;
          name: string;
          state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
          errors?: ErrorDataSchema[];
          revision?: string;
          createdAt?: string;
          updatedAt?: string;
          archivedAt?: string;
          isDeactivated?: boolean;
          isCustomized?: boolean;
      },
  >

  Returns Promise<
      {
          integration?: {
              logoUri: string;
              connectorId?: string;
              connectorVersion?: string;
              oAuthCallbackUri?: string;
              parameters?: any;
              archivedAt?: string;
              hasMissingParameters?: boolean;
              hasDocumentation?: boolean;
              hasOperations?: boolean;
              operationsCount?: number;
              hasData?: boolean;
              dataCollectionsCount?: number;
              hasEvents?: boolean;
              eventsCount?: number;
              hasGlobalWebhooks?: boolean;
              hasUdm?: boolean;
              isTest?: boolean;
              appUuid?: string;
              isDeactivated?: boolean;
              authType?: | "proxy"
              | "integration-app-token"
              | "membrane-token"
              | "oauth2"
              | "oauth1"
              | "client-credentials";
              id: string;
              key?: string;
              uuid?: string;
              description?: string;
              meta?: Record<string, any>;
              name: string;
              state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
              errors?: ErrorDataSchema[];
              revision?: string;
              createdAt?: string;
              updatedAt?: string;
          };
          appliedToIntegrations?: {
              element: {
                  id: string;
                  integrationId?: string;
                  isCustomized?: boolean;
                  universalFlowId?: string;
              };
              integration: {
                  logoUri: string;
                  connectorId?: string;
                  connectorVersion?: string;
                  oAuthCallbackUri?: string;
                  parameters?: any;
                  archivedAt?: string;
                  hasMissingParameters?: boolean;
                  hasDocumentation?: boolean;
                  hasOperations?: boolean;
                  operationsCount?: number;
                  hasData?: boolean;
                  dataCollectionsCount?: number;
                  hasEvents?: boolean;
                  eventsCount?: number;
                  hasGlobalWebhooks?: boolean;
                  hasUdm?: boolean;
                  isTest?: boolean;
                  appUuid?: string;
                  isDeactivated?: boolean;
                  authType?: | "proxy"
                  | "integration-app-token"
                  | "membrane-token"
                  | "oauth2"
                  | "oauth1"
                  | "client-credentials";
                  id: string;
                  key?: string;
                  uuid?: string;
                  description?: string;
                  meta?: Record<string, any>;
                  name: string;
                  state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
                  errors?: ErrorDataSchema[];
                  revision?: string;
                  createdAt?: string;
                  updatedAt?: string;
              };
          }[];
          dependencies?: any[];
          integrationId?: string;
          universalFlowId?: string;
          parametersSchema?: DataSchema;
          nodes?: Record<
              string,
              {
                  type?: string;
                  version?: number;
                  name?: string;
                  description?: string;
                  config?: any;
                  concurrency?: number;
                  onError?: "continue"
                  | "stop";
                  ui?: any;
                  inputSchema?: any;
                  outputSchema?: any;
                  outputExample?: any;
                  links?: { key?: string; filter?: any; name?: string }[];
                  isCustomized?: boolean;
              },
          >;
          autoCreateInstances?: boolean;
          universalFlowRevision?: string;
          id: string;
          key?: string;
          uuid?: string;
          description?: string;
          meta?: Record<string, any>;
          name: string;
          state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
          errors?: ErrorDataSchema[];
          revision?: string;
          createdAt?: string;
          updatedAt?: string;
          archivedAt?: string;
          isDeactivated?: boolean;
          isCustomized?: boolean;
      },
  >

patch

• patch(
      data: Partial<UpdateElementData>,
  ): Promise<
      {
          integration?: {
              logoUri: string;
              connectorId?: string;
              connectorVersion?: string;
              oAuthCallbackUri?: string;
              parameters?: any;
              archivedAt?: string;
              hasMissingParameters?: boolean;
              hasDocumentation?: boolean;
              hasOperations?: boolean;
              operationsCount?: number;
              hasData?: boolean;
              dataCollectionsCount?: number;
              hasEvents?: boolean;
              eventsCount?: number;
              hasGlobalWebhooks?: boolean;
              hasUdm?: boolean;
              isTest?: boolean;
              appUuid?: string;
              isDeactivated?: boolean;
              authType?: | "proxy"
              | "integration-app-token"
              | "membrane-token"
              | "oauth2"
              | "oauth1"
              | "client-credentials";
              id: string;
              key?: string;
              uuid?: string;
              description?: string;
              meta?: Record<string, any>;
              name: string;
              state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
              errors?: ErrorDataSchema[];
              revision?: string;
              createdAt?: string;
              updatedAt?: string;
          };
          appliedToIntegrations?: {
              element: {
                  id: string;
                  integrationId?: string;
                  isCustomized?: boolean;
                  universalFlowId?: string;
              };
              integration: {
                  logoUri: string;
                  connectorId?: string;
                  connectorVersion?: string;
                  oAuthCallbackUri?: string;
                  parameters?: any;
                  archivedAt?: string;
                  hasMissingParameters?: boolean;
                  hasDocumentation?: boolean;
                  hasOperations?: boolean;
                  operationsCount?: number;
                  hasData?: boolean;
                  dataCollectionsCount?: number;
                  hasEvents?: boolean;
                  eventsCount?: number;
                  hasGlobalWebhooks?: boolean;
                  hasUdm?: boolean;
                  isTest?: boolean;
                  appUuid?: string;
                  isDeactivated?: boolean;
                  authType?: | "proxy"
                  | "integration-app-token"
                  | "membrane-token"
                  | "oauth2"
                  | "oauth1"
                  | "client-credentials";
                  id: string;
                  key?: string;
                  uuid?: string;
                  description?: string;
                  meta?: Record<string, any>;
                  name: string;
                  state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
                  errors?: ErrorDataSchema[];
                  revision?: string;
                  createdAt?: string;
                  updatedAt?: string;
              };
          }[];
          dependencies?: any[];
          integrationId?: string;
          universalFlowId?: string;
          parametersSchema?: DataSchema;
          nodes?: Record<
              string,
              {
                  type?: string;
                  version?: number;
                  name?: string;
                  description?: string;
                  config?: any;
                  concurrency?: number;
                  onError?: "continue"
                  | "stop";
                  ui?: any;
                  inputSchema?: any;
                  outputSchema?: any;
                  outputExample?: any;
                  links?: { key?: string; filter?: any; name?: string }[];
                  isCustomized?: boolean;
              },
          >;
          autoCreateInstances?: boolean;
          universalFlowRevision?: string;
          id: string;
          key?: string;
          uuid?: string;
          description?: string;
          meta?: Record<string, any>;
          name: string;
          state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
          errors?: ErrorDataSchema[];
          revision?: string;
          createdAt?: string;
          updatedAt?: string;
          archivedAt?: string;
          isDeactivated?: boolean;
          isCustomized?: boolean;
      },
  >

  Parameters

  • data: Partial<UpdateElementData>

  Returns Promise<
      {
          integration?: {
              logoUri: string;
              connectorId?: string;
              connectorVersion?: string;
              oAuthCallbackUri?: string;
              parameters?: any;
              archivedAt?: string;
              hasMissingParameters?: boolean;
              hasDocumentation?: boolean;
              hasOperations?: boolean;
              operationsCount?: number;
              hasData?: boolean;
              dataCollectionsCount?: number;
              hasEvents?: boolean;
              eventsCount?: number;
              hasGlobalWebhooks?: boolean;
              hasUdm?: boolean;
              isTest?: boolean;
              appUuid?: string;
              isDeactivated?: boolean;
              authType?: | "proxy"
              | "integration-app-token"
              | "membrane-token"
              | "oauth2"
              | "oauth1"
              | "client-credentials";
              id: string;
              key?: string;
              uuid?: string;
              description?: string;
              meta?: Record<string, any>;
              name: string;
              state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
              errors?: ErrorDataSchema[];
              revision?: string;
              createdAt?: string;
              updatedAt?: string;
          };
          appliedToIntegrations?: {
              element: {
                  id: string;
                  integrationId?: string;
                  isCustomized?: boolean;
                  universalFlowId?: string;
              };
              integration: {
                  logoUri: string;
                  connectorId?: string;
                  connectorVersion?: string;
                  oAuthCallbackUri?: string;
                  parameters?: any;
                  archivedAt?: string;
                  hasMissingParameters?: boolean;
                  hasDocumentation?: boolean;
                  hasOperations?: boolean;
                  operationsCount?: number;
                  hasData?: boolean;
                  dataCollectionsCount?: number;
                  hasEvents?: boolean;
                  eventsCount?: number;
                  hasGlobalWebhooks?: boolean;
                  hasUdm?: boolean;
                  isTest?: boolean;
                  appUuid?: string;
                  isDeactivated?: boolean;
                  authType?: | "proxy"
                  | "integration-app-token"
                  | "membrane-token"
                  | "oauth2"
                  | "oauth1"
                  | "client-credentials";
                  id: string;
                  key?: string;
                  uuid?: string;
                  description?: string;
                  meta?: Record<string, any>;
                  name: string;
                  state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
                  errors?: ErrorDataSchema[];
                  revision?: string;
                  createdAt?: string;
                  updatedAt?: string;
              };
          }[];
          dependencies?: any[];
          integrationId?: string;
          universalFlowId?: string;
          parametersSchema?: DataSchema;
          nodes?: Record<
              string,
              {
                  type?: string;
                  version?: number;
                  name?: string;
                  description?: string;
                  config?: any;
                  concurrency?: number;
                  onError?: "continue"
                  | "stop";
                  ui?: any;
                  inputSchema?: any;
                  outputSchema?: any;
                  outputExample?: any;
                  links?: { key?: string; filter?: any; name?: string }[];
                  isCustomized?: boolean;
              },
          >;
          autoCreateInstances?: boolean;
          universalFlowRevision?: string;
          id: string;
          key?: string;
          uuid?: string;
          description?: string;
          meta?: Record<string, any>;
          name: string;
          state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
          errors?: ErrorDataSchema[];
          revision?: string;
          createdAt?: string;
          updatedAt?: string;
          archivedAt?: string;
          isDeactivated?: boolean;
          isCustomized?: boolean;
      },
  >

put

• put(
      data: {
          integrationId?: string;
          universalFlowId?: string;
          parametersSchema?: DataSchema;
          nodes?: Record<
              string,
              {
                  type?: string;
                  version?: number;
                  name?: string;
                  description?: string;
                  config?: any;
                  concurrency?: number;
                  onError?: "continue"
                  | "stop";
                  ui?: any;
                  inputSchema?: any;
                  outputSchema?: any;
                  outputExample?: any;
                  links?: { key?: string; filter?: any; name?: string }[];
                  isCustomized?: boolean;
              },
          >;
          autoCreateInstances?: boolean;
          key?: string;
          name?: string;
          uuid?: string;
          description?: string;
          meta?: Record<string, any>;
      },
  ): Promise<
      {
          integration?: {
              logoUri: string;
              connectorId?: string;
              connectorVersion?: string;
              oAuthCallbackUri?: string;
              parameters?: any;
              archivedAt?: string;
              hasMissingParameters?: boolean;
              hasDocumentation?: boolean;
              hasOperations?: boolean;
              operationsCount?: number;
              hasData?: boolean;
              dataCollectionsCount?: number;
              hasEvents?: boolean;
              eventsCount?: number;
              hasGlobalWebhooks?: boolean;
              hasUdm?: boolean;
              isTest?: boolean;
              appUuid?: string;
              isDeactivated?: boolean;
              authType?: | "proxy"
              | "integration-app-token"
              | "membrane-token"
              | "oauth2"
              | "oauth1"
              | "client-credentials";
              id: string;
              key?: string;
              uuid?: string;
              description?: string;
              meta?: Record<string, any>;
              name: string;
              state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
              errors?: ErrorDataSchema[];
              revision?: string;
              createdAt?: string;
              updatedAt?: string;
          };
          appliedToIntegrations?: {
              element: {
                  id: string;
                  integrationId?: string;
                  isCustomized?: boolean;
                  universalFlowId?: string;
              };
              integration: {
                  logoUri: string;
                  connectorId?: string;
                  connectorVersion?: string;
                  oAuthCallbackUri?: string;
                  parameters?: any;
                  archivedAt?: string;
                  hasMissingParameters?: boolean;
                  hasDocumentation?: boolean;
                  hasOperations?: boolean;
                  operationsCount?: number;
                  hasData?: boolean;
                  dataCollectionsCount?: number;
                  hasEvents?: boolean;
                  eventsCount?: number;
                  hasGlobalWebhooks?: boolean;
                  hasUdm?: boolean;
                  isTest?: boolean;
                  appUuid?: string;
                  isDeactivated?: boolean;
                  authType?: | "proxy"
                  | "integration-app-token"
                  | "membrane-token"
                  | "oauth2"
                  | "oauth1"
                  | "client-credentials";
                  id: string;
                  key?: string;
                  uuid?: string;
                  description?: string;
                  meta?: Record<string, any>;
                  name: string;
                  state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
                  errors?: ErrorDataSchema[];
                  revision?: string;
                  createdAt?: string;
                  updatedAt?: string;
              };
          }[];
          dependencies?: any[];
          integrationId?: string;
          universalFlowId?: string;
          parametersSchema?: DataSchema;
          nodes?: Record<
              string,
              {
                  type?: string;
                  version?: number;
                  name?: string;
                  description?: string;
                  config?: any;
                  concurrency?: number;
                  onError?: "continue"
                  | "stop";
                  ui?: any;
                  inputSchema?: any;
                  outputSchema?: any;
                  outputExample?: any;
                  links?: { key?: string; filter?: any; name?: string }[];
                  isCustomized?: boolean;
              },
          >;
          autoCreateInstances?: boolean;
          universalFlowRevision?: string;
          id: string;
          key?: string;
          uuid?: string;
          description?: string;
          meta?: Record<string, any>;
          name: string;
          state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
          errors?: ErrorDataSchema[];
          revision?: string;
          createdAt?: string;
          updatedAt?: string;
          archivedAt?: string;
          isDeactivated?: boolean;
          isCustomized?: boolean;
      },
  >

  Parameters

  • data: {
        integrationId?: string;
        universalFlowId?: string;
        parametersSchema?: DataSchema;
        nodes?: Record<
            string,
            {
                type?: string;
                version?: number;
                name?: string;
                description?: string;
                config?: any;
                concurrency?: number;
                onError?: "continue"
                | "stop";
                ui?: any;
                inputSchema?: any;
                outputSchema?: any;
                outputExample?: any;
                links?: { key?: string; filter?: any; name?: string }[];
                isCustomized?: boolean;
            },
        >;
        autoCreateInstances?: boolean;
        key?: string;
        name?: string;
        uuid?: string;
        description?: string;
        meta?: Record<string, any>;
    }

    • OptionalintegrationId?: string

    • OptionaluniversalFlowId?: string

    • OptionalparametersSchema?: DataSchema

      DataSchema of parameters provided during the flow creation. Can be used to configure the flow logic.

    • Optionalnodes?: Record<
          string,
          {
              type?: string;
              version?: number;
              name?: string;
              description?: string;
              config?: any;
              concurrency?: number;
              onError?: "continue"
              | "stop";
              ui?: any;
              inputSchema?: any;
              outputSchema?: any;
              outputExample?: any;
              links?: { key?: string; filter?: any; name?: string }[];
              isCustomized?: boolean;
          },
      >

      Flow Nodes in the format :

    • OptionalautoCreateInstances?: boolean

      Automatically create a Flow Instance when a Connection is created.

    • Optionalkey?: string

    • Optionalname?: string

    • Optionaluuid?: string

    • Optionaldescription?: string

    • Optionalmeta?: Record<string, any>

  Returns Promise<
      {
          integration?: {
              logoUri: string;
              connectorId?: string;
              connectorVersion?: string;
              oAuthCallbackUri?: string;
              parameters?: any;
              archivedAt?: string;
              hasMissingParameters?: boolean;
              hasDocumentation?: boolean;
              hasOperations?: boolean;
              operationsCount?: number;
              hasData?: boolean;
              dataCollectionsCount?: number;
              hasEvents?: boolean;
              eventsCount?: number;
              hasGlobalWebhooks?: boolean;
              hasUdm?: boolean;
              isTest?: boolean;
              appUuid?: string;
              isDeactivated?: boolean;
              authType?: | "proxy"
              | "integration-app-token"
              | "membrane-token"
              | "oauth2"
              | "oauth1"
              | "client-credentials";
              id: string;
              key?: string;
              uuid?: string;
              description?: string;
              meta?: Record<string, any>;
              name: string;
              state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
              errors?: ErrorDataSchema[];
              revision?: string;
              createdAt?: string;
              updatedAt?: string;
          };
          appliedToIntegrations?: {
              element: {
                  id: string;
                  integrationId?: string;
                  isCustomized?: boolean;
                  universalFlowId?: string;
              };
              integration: {
                  logoUri: string;
                  connectorId?: string;
                  connectorVersion?: string;
                  oAuthCallbackUri?: string;
                  parameters?: any;
                  archivedAt?: string;
                  hasMissingParameters?: boolean;
                  hasDocumentation?: boolean;
                  hasOperations?: boolean;
                  operationsCount?: number;
                  hasData?: boolean;
                  dataCollectionsCount?: number;
                  hasEvents?: boolean;
                  eventsCount?: number;
                  hasGlobalWebhooks?: boolean;
                  hasUdm?: boolean;
                  isTest?: boolean;
                  appUuid?: string;
                  isDeactivated?: boolean;
                  authType?: | "proxy"
                  | "integration-app-token"
                  | "membrane-token"
                  | "oauth2"
                  | "oauth1"
                  | "client-credentials";
                  id: string;
                  key?: string;
                  uuid?: string;
                  description?: string;
                  meta?: Record<string, any>;
                  name: string;
                  state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
                  errors?: ErrorDataSchema[];
                  revision?: string;
                  createdAt?: string;
                  updatedAt?: string;
              };
          }[];
          dependencies?: any[];
          integrationId?: string;
          universalFlowId?: string;
          parametersSchema?: DataSchema;
          nodes?: Record<
              string,
              {
                  type?: string;
                  version?: number;
                  name?: string;
                  description?: string;
                  config?: any;
                  concurrency?: number;
                  onError?: "continue"
                  | "stop";
                  ui?: any;
                  inputSchema?: any;
                  outputSchema?: any;
                  outputExample?: any;
                  links?: { key?: string; filter?: any; name?: string }[];
                  isCustomized?: boolean;
              },
          >;
          autoCreateInstances?: boolean;
          universalFlowRevision?: string;
          id: string;
          key?: string;
          uuid?: string;
          description?: string;
          meta?: Record<string, any>;
          name: string;
          state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
          errors?: ErrorDataSchema[];
          revision?: string;
          createdAt?: string;
          updatedAt?: string;
          archivedAt?: string;
          isDeactivated?: boolean;
          isCustomized?: boolean;
      },
  >

archive

• archive(): Promise<void>

  Returns Promise<void>

reset

• reset(): Promise<
      {
          integration?: {
              logoUri: string;
              connectorId?: string;
              connectorVersion?: string;
              oAuthCallbackUri?: string;
              parameters?: any;
              archivedAt?: string;
              hasMissingParameters?: boolean;
              hasDocumentation?: boolean;
              hasOperations?: boolean;
              operationsCount?: number;
              hasData?: boolean;
              dataCollectionsCount?: number;
              hasEvents?: boolean;
              eventsCount?: number;
              hasGlobalWebhooks?: boolean;
              hasUdm?: boolean;
              isTest?: boolean;
              appUuid?: string;
              isDeactivated?: boolean;
              authType?: | "proxy"
              | "integration-app-token"
              | "membrane-token"
              | "oauth2"
              | "oauth1"
              | "client-credentials";
              id: string;
              key?: string;
              uuid?: string;
              description?: string;
              meta?: Record<string, any>;
              name: string;
              state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
              errors?: ErrorDataSchema[];
              revision?: string;
              createdAt?: string;
              updatedAt?: string;
          };
          appliedToIntegrations?: {
              element: {
                  id: string;
                  integrationId?: string;
                  isCustomized?: boolean;
                  universalFlowId?: string;
              };
              integration: {
                  logoUri: string;
                  connectorId?: string;
                  connectorVersion?: string;
                  oAuthCallbackUri?: string;
                  parameters?: any;
                  archivedAt?: string;
                  hasMissingParameters?: boolean;
                  hasDocumentation?: boolean;
                  hasOperations?: boolean;
                  operationsCount?: number;
                  hasData?: boolean;
                  dataCollectionsCount?: number;
                  hasEvents?: boolean;
                  eventsCount?: number;
                  hasGlobalWebhooks?: boolean;
                  hasUdm?: boolean;
                  isTest?: boolean;
                  appUuid?: string;
                  isDeactivated?: boolean;
                  authType?: | "proxy"
                  | "integration-app-token"
                  | "membrane-token"
                  | "oauth2"
                  | "oauth1"
                  | "client-credentials";
                  id: string;
                  key?: string;
                  uuid?: string;
                  description?: string;
                  meta?: Record<string, any>;
                  name: string;
                  state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
                  errors?: ErrorDataSchema[];
                  revision?: string;
                  createdAt?: string;
                  updatedAt?: string;
              };
          }[];
          dependencies?: any[];
          integrationId?: string;
          universalFlowId?: string;
          parametersSchema?: DataSchema;
          nodes?: Record<
              string,
              {
                  type?: string;
                  version?: number;
                  name?: string;
                  description?: string;
                  config?: any;
                  concurrency?: number;
                  onError?: "continue"
                  | "stop";
                  ui?: any;
                  inputSchema?: any;
                  outputSchema?: any;
                  outputExample?: any;
                  links?: { key?: string; filter?: any; name?: string }[];
                  isCustomized?: boolean;
              },
          >;
          autoCreateInstances?: boolean;
          universalFlowRevision?: string;
          id: string;
          key?: string;
          uuid?: string;
          description?: string;
          meta?: Record<string, any>;
          name: string;
          state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
          errors?: ErrorDataSchema[];
          revision?: string;
          createdAt?: string;
          updatedAt?: string;
          archivedAt?: string;
          isDeactivated?: boolean;
          isCustomized?: boolean;
      },
  >

  Returns Promise<
      {
          integration?: {
              logoUri: string;
              connectorId?: string;
              connectorVersion?: string;
              oAuthCallbackUri?: string;
              parameters?: any;
              archivedAt?: string;
              hasMissingParameters?: boolean;
              hasDocumentation?: boolean;
              hasOperations?: boolean;
              operationsCount?: number;
              hasData?: boolean;
              dataCollectionsCount?: number;
              hasEvents?: boolean;
              eventsCount?: number;
              hasGlobalWebhooks?: boolean;
              hasUdm?: boolean;
              isTest?: boolean;
              appUuid?: string;
              isDeactivated?: boolean;
              authType?: | "proxy"
              | "integration-app-token"
              | "membrane-token"
              | "oauth2"
              | "oauth1"
              | "client-credentials";
              id: string;
              key?: string;
              uuid?: string;
              description?: string;
              meta?: Record<string, any>;
              name: string;
              state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
              errors?: ErrorDataSchema[];
              revision?: string;
              createdAt?: string;
              updatedAt?: string;
          };
          appliedToIntegrations?: {
              element: {
                  id: string;
                  integrationId?: string;
                  isCustomized?: boolean;
                  universalFlowId?: string;
              };
              integration: {
                  logoUri: string;
                  connectorId?: string;
                  connectorVersion?: string;
                  oAuthCallbackUri?: string;
                  parameters?: any;
                  archivedAt?: string;
                  hasMissingParameters?: boolean;
                  hasDocumentation?: boolean;
                  hasOperations?: boolean;
                  operationsCount?: number;
                  hasData?: boolean;
                  dataCollectionsCount?: number;
                  hasEvents?: boolean;
                  eventsCount?: number;
                  hasGlobalWebhooks?: boolean;
                  hasUdm?: boolean;
                  isTest?: boolean;
                  appUuid?: string;
                  isDeactivated?: boolean;
                  authType?: | "proxy"
                  | "integration-app-token"
                  | "membrane-token"
                  | "oauth2"
                  | "oauth1"
                  | "client-credentials";
                  id: string;
                  key?: string;
                  uuid?: string;
                  description?: string;
                  meta?: Record<string, any>;
                  name: string;
                  state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
                  errors?: ErrorDataSchema[];
                  revision?: string;
                  createdAt?: string;
                  updatedAt?: string;
              };
          }[];
          dependencies?: any[];
          integrationId?: string;
          universalFlowId?: string;
          parametersSchema?: DataSchema;
          nodes?: Record<
              string,
              {
                  type?: string;
                  version?: number;
                  name?: string;
                  description?: string;
                  config?: any;
                  concurrency?: number;
                  onError?: "continue"
                  | "stop";
                  ui?: any;
                  inputSchema?: any;
                  outputSchema?: any;
                  outputExample?: any;
                  links?: { key?: string; filter?: any; name?: string }[];
                  isCustomized?: boolean;
              },
          >;
          autoCreateInstances?: boolean;
          universalFlowRevision?: string;
          id: string;
          key?: string;
          uuid?: string;
          description?: string;
          meta?: Record<string, any>;
          name: string;
          state?: CONFIGURATION_ERROR | SETUP_FAILED | READY;
          errors?: ErrorDataSchema[];
          revision?: string;
          createdAt?: string;
          updatedAt?: string;
          archivedAt?: string;
          isDeactivated?: boolean;
          isCustomized?: boolean;
      },
  >