great 0.3.2 → 1.0.2

package/dist/generated/graphql.d.ts

@@ -0,0 +1,1784 @@
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = T | null;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    Date: {
+        input: any;
+        output: any;
+    };
+    DateTime: {
+        input: any;
+        output: any;
+    };
+    JSON: {
+        input: any;
+        output: any;
+    };
+    PrimitiveValue: {
+        input: any;
+        output: any;
+    };
+};
+export type Account = {
+    __typename?: 'Account';
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    integrations: IntegrationConnection;
+    key: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    status: Status;
+    updatedAt: Scalars['DateTime']['output'];
+    users: AccountUsersEdgeConnection;
+};
+export type AccountIntegrationsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    direction?: InputMaybe<Direction>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<IntegrationOrderField>;
+};
+export type AccountConnection = {
+    __typename?: 'AccountConnection';
+    nodes: Array<Account>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export declare enum AccountOrderField {
+    CreatedAt = "createdAt",
+    Name = "name",
+    UpdatedAt = "updatedAt"
+}
+export declare enum AccountRole {
+    Admin = "admin",
+    Member = "member",
+    Owner = "owner"
+}
+export type AccountUserEdge = {
+    __typename?: 'AccountUserEdge';
+    cursor: Scalars['String']['output'];
+    role: AccountRole;
+    user: User;
+};
+export type AccountUsersEdgeConnection = {
+    __typename?: 'AccountUsersEdgeConnection';
+    edges: Array<AccountUserEdge>;
+    nodes: Array<User>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type Auth = Element & {
+    __typename?: 'Auth';
+    content?: Maybe<ElementContent>;
+    createdAt: Scalars['DateTime']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    key: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type ConfigElement = Element & {
+    __typename?: 'ConfigElement';
+    content?: Maybe<ElementContent>;
+    createdAt: Scalars['DateTime']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    key: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type Dictionary = Element & {
+    __typename?: 'Dictionary';
+    content?: Maybe<ElementContent>;
+    createdAt: Scalars['DateTime']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    key: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export declare enum Direction {
+    Asc = "asc",
+    Desc = "desc"
+}
+export type Element = {
+    content?: Maybe<ElementContent>;
+    createdAt: Scalars['DateTime']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    key: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type ElementContent = {
+    __typename?: 'ElementContent';
+    checksum?: Maybe<Scalars['String']['output']>;
+    data?: Maybe<Scalars['JSON']['output']>;
+    timestamp: Scalars['Date']['output'];
+};
+export declare enum ElementType {
+    Auth = "auth",
+    Config = "config",
+    Dictionary = "dictionary",
+    Flow = "flow",
+    Job = "job",
+    Mutation = "mutation",
+    RetryRule = "retryRule",
+    Schema = "schema",
+    Service = "service",
+    Value = "value"
+}
+export type Flow = Element & {
+    __typename?: 'Flow';
+    content?: Maybe<ElementContent>;
+    createdAt: Scalars['DateTime']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    key: Scalars['ID']['output'];
+    lastRun?: Maybe<Log>;
+    name: Scalars['String']['output'];
+    sort?: Maybe<Scalars['Int']['output']>;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type Integration = {
+    __typename?: 'Integration';
+    account: Account;
+    active?: Maybe<Version>;
+    createdAt: Scalars['DateTime']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    key: Scalars['ID']['output'];
+    latest: Version;
+    logEntries: LogEntryConnection;
+    logs: LogConnection;
+    name: Scalars['String']['output'];
+    notifications: NotificationConnection;
+    status: Status;
+    updatedAt: Scalars['DateTime']['output'];
+    versions: Array<Version>;
+};
+export type IntegrationLogEntriesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    direction?: InputMaybe<Direction>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+};
+export type IntegrationLogsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    direction?: InputMaybe<Direction>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+};
+export type IntegrationNotificationsArgs = {
+    isAcknowledged?: InputMaybe<Scalars['Boolean']['input']>;
+};
+export type IntegrationConnection = {
+    __typename?: 'IntegrationConnection';
+    nodes: Array<Integration>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export declare enum IntegrationOrderField {
+    Account = "account",
+    CreatedAt = "createdAt",
+    Name = "name",
+    UpdatedAt = "updatedAt"
+}
+export type Job = Element & {
+    __typename?: 'Job';
+    content?: Maybe<ElementContent>;
+    createdAt: Scalars['DateTime']['output'];
+    cron?: Maybe<Scalars['String']['output']>;
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    isSubJob?: Maybe<Scalars['Boolean']['output']>;
+    key: Scalars['ID']['output'];
+    lastRun?: Maybe<Log>;
+    name: Scalars['String']['output'];
+    sort?: Maybe<Scalars['Int']['output']>;
+    tz?: Maybe<Scalars['String']['output']>;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type Log = {
+    __typename?: 'Log';
+    action?: Maybe<Scalars['String']['output']>;
+    children: LogConnection;
+    completedAt?: Maybe<Scalars['DateTime']['output']>;
+    correlationId: Scalars['String']['output'];
+    expireDataAt?: Maybe<Scalars['DateTime']['output']>;
+    id: Scalars['ID']['output'];
+    identId?: Maybe<Scalars['String']['output']>;
+    retryCount: Scalars['Int']['output'];
+    startedAt: Scalars['DateTime']['output'];
+    status?: Maybe<LogStatus>;
+    title: Scalars['String']['output'];
+    type: LogType;
+};
+export type LogChildrenArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    direction?: InputMaybe<Direction>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+};
+export type LogConnection = {
+    __typename?: 'LogConnection';
+    nodes: Array<Log>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type LogEntry = {
+    __typename?: 'LogEntry';
+    action?: Maybe<Scalars['String']['output']>;
+    correlationId: Scalars['String']['output'];
+    expireDataAt?: Maybe<Scalars['DateTime']['output']>;
+    id: Scalars['ID']['output'];
+    identId?: Maybe<Scalars['String']['output']>;
+    retryCount: Scalars['Int']['output'];
+    status?: Maybe<LogStatus>;
+    timestamp: Scalars['DateTime']['output'];
+    title: Scalars['String']['output'];
+    type: LogType;
+};
+export type LogEntryConnection = {
+    __typename?: 'LogEntryConnection';
+    nodes: Array<LogEntry>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export declare enum LogStatus {
+    Autherror = "autherror",
+    Badrequest = "badrequest",
+    Badresponse = "badresponse",
+    Error = "error",
+    Noaccess = "noaccess",
+    Noaction = "noaction",
+    Notfound = "notfound",
+    Ok = "ok",
+    Pending = "pending",
+    Queued = "queued",
+    Queuing = "queuing",
+    Starting = "starting",
+    Timeout = "timeout",
+    Toomany = "toomany"
+}
+export declare enum LogType {
+    Action = "action",
+    Load = "load",
+    Response = "response",
+    Schedule = "schedule",
+    Unload = "unload"
+}
+export type Message = {
+    __typename?: 'Message';
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    message: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+    user: User;
+};
+export type MessageConnection = {
+    __typename?: 'MessageConnection';
+    nodes: Array<Message>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type Mutation = {
+    __typename?: 'Mutation';
+    acknowledgeNotification: Notification;
+    addParticipant: Participant;
+    createAccount: Account;
+    createElement: Element;
+    createIntegration: Integration;
+    createThread: Thread;
+    createUser: User;
+    createVersion: Version;
+    deleteAccount: Scalars['Boolean']['output'];
+    deleteElement: Element;
+    deleteIntegration: Scalars['Boolean']['output'];
+    deleteThread: Thread;
+    dispatch: Response;
+    includeElement: Element;
+    postMessage: Message;
+    removeParticipant: Participant;
+    setElementContent: Element;
+    setValue: Scalars['Boolean']['output'];
+    startIntegration: Integration;
+    stopIntegration: Integration;
+    updateAccountKey: Account;
+    updateAccountName: Account;
+    updateElement: Element;
+    updateElementKey: Element;
+    updateIntegration: Integration;
+    updateIntegrationKey: Integration;
+    updateThreadTitle: Thread;
+    updateUserEmail: User;
+    updateUserName: User;
+    updateVersion: Version;
+};
+export type MutationAcknowledgeNotificationArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationAddParticipantArgs = {
+    threadId: Scalars['ID']['input'];
+    userId: Scalars['ID']['input'];
+};
+export type MutationCreateAccountArgs = {
+    key?: InputMaybe<Scalars['ID']['input']>;
+    name: Scalars['String']['input'];
+};
+export type MutationCreateElementArgs = {
+    description?: InputMaybe<Scalars['String']['input']>;
+    integrationId: Scalars['ID']['input'];
+    key: Scalars['ID']['input'];
+    name: Scalars['String']['input'];
+    type: ElementType;
+};
+export type MutationCreateIntegrationArgs = {
+    accountId: Scalars['ID']['input'];
+    description?: InputMaybe<Scalars['String']['input']>;
+    key?: InputMaybe<Scalars['ID']['input']>;
+    name: Scalars['String']['input'];
+};
+export type MutationCreateThreadArgs = {
+    title: Scalars['String']['input'];
+};
+export type MutationCreateUserArgs = {
+    email: Scalars['String']['input'];
+    name: Scalars['String']['input'];
+};
+export type MutationCreateVersionArgs = {
+    integrationId: Scalars['ID']['input'];
+    name?: InputMaybe<Scalars['String']['input']>;
+    timestamp?: InputMaybe<Scalars['DateTime']['input']>;
+};
+export type MutationDeleteAccountArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteElementArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteIntegrationArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteThreadArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDispatchArgs = {
+    integrationId: Scalars['ID']['input'];
+    payload: Scalars['JSON']['input'];
+    type: Scalars['String']['input'];
+    waitForResponse?: InputMaybe<Scalars['Boolean']['input']>;
+};
+export type MutationIncludeElementArgs = {
+    elementId: Scalars['ID']['input'];
+    integrationId: Scalars['ID']['input'];
+};
+export type MutationPostMessageArgs = {
+    message: Scalars['String']['input'];
+    threadId: Scalars['ID']['input'];
+};
+export type MutationRemoveParticipantArgs = {
+    threadId: Scalars['ID']['input'];
+    userId: Scalars['ID']['input'];
+};
+export type MutationSetElementContentArgs = {
+    content?: InputMaybe<Scalars['JSON']['input']>;
+    id: Scalars['ID']['input'];
+};
+export type MutationSetValueArgs = {
+    id: Scalars['ID']['input'];
+    value: Scalars['PrimitiveValue']['input'];
+};
+export type MutationStartIntegrationArgs = {
+    id: Scalars['ID']['input'];
+    versionId?: InputMaybe<Scalars['ID']['input']>;
+};
+export type MutationStopIntegrationArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationUpdateAccountKeyArgs = {
+    id: Scalars['ID']['input'];
+    key: Scalars['ID']['input'];
+};
+export type MutationUpdateAccountNameArgs = {
+    id: Scalars['ID']['input'];
+    name: Scalars['String']['input'];
+};
+export type MutationUpdateElementArgs = {
+    description?: InputMaybe<Scalars['String']['input']>;
+    id: Scalars['ID']['input'];
+    name?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationUpdateElementKeyArgs = {
+    id: Scalars['ID']['input'];
+    key: Scalars['ID']['input'];
+};
+export type MutationUpdateIntegrationArgs = {
+    description?: InputMaybe<Scalars['String']['input']>;
+    id: Scalars['ID']['input'];
+    name?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationUpdateIntegrationKeyArgs = {
+    id: Scalars['ID']['input'];
+    key: Scalars['ID']['input'];
+};
+export type MutationUpdateThreadTitleArgs = {
+    id: Scalars['ID']['input'];
+    title: Scalars['String']['input'];
+};
+export type MutationUpdateUserEmailArgs = {
+    email: Scalars['String']['input'];
+    id: Scalars['ID']['input'];
+};
+export type MutationUpdateUserNameArgs = {
+    id: Scalars['ID']['input'];
+    name: Scalars['String']['input'];
+};
+export type MutationUpdateVersionArgs = {
+    id: Scalars['ID']['input'];
+    name?: InputMaybe<Scalars['String']['input']>;
+};
+export type Notification = {
+    __typename?: 'Notification';
+    acknowledgedAt?: Maybe<Scalars['DateTime']['output']>;
+    acknowledgedByUser?: Maybe<User>;
+    createdAt: Scalars['DateTime']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    integration?: Maybe<Integration>;
+    isAcknowledged: Scalars['Boolean']['output'];
+    log?: Maybe<LogEntry>;
+    title: Scalars['String']['output'];
+    type: NotificationType;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type NotificationConnection = {
+    __typename?: 'NotificationConnection';
+    nodes: Array<Notification>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export declare enum NotificationType {
+    Failure = "failure",
+    Warning = "warning"
+}
+export type PageInfo = {
+    __typename?: 'PageInfo';
+    endCursor?: Maybe<Scalars['String']['output']>;
+    hasNextPage: Scalars['Boolean']['output'];
+    hasPreviousPage: Scalars['Boolean']['output'];
+    startCursor?: Maybe<Scalars['String']['output']>;
+};
+export type Participant = {
+    __typename?: 'Participant';
+    lastSeenAt?: Maybe<Scalars['DateTime']['output']>;
+    thread: Thread;
+    user: User;
+};
+export type ParticipantConnection = {
+    __typename?: 'ParticipantConnection';
+    edges: Array<ParticipantEdge>;
+    nodes: Array<User>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type ParticipantEdge = {
+    __typename?: 'ParticipantEdge';
+    cursor: Scalars['String']['output'];
+    lastSeenAt?: Maybe<Scalars['DateTime']['output']>;
+    lastSeenMessage?: Maybe<Message>;
+    user: User;
+};
+export type Query = {
+    __typename?: 'Query';
+    account?: Maybe<Account>;
+    accountByKey?: Maybe<Account>;
+    accounts?: Maybe<AccountConnection>;
+    element: Element;
+    elementByKey: Element;
+    integration?: Maybe<Integration>;
+    integrationByKey?: Maybe<Integration>;
+    integrations: IntegrationConnection;
+    log: Log;
+    logEntry: LogEntry;
+    notifications: NotificationConnection;
+    session: Session;
+    thread: Thread;
+    threads: ThreadConnection;
+    user?: Maybe<User>;
+    users?: Maybe<UserConnection>;
+};
+export type QueryAccountArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryAccountByKeyArgs = {
+    key: Scalars['ID']['input'];
+};
+export type QueryAccountsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    direction?: InputMaybe<Direction>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<AccountOrderField>;
+};
+export type QueryElementArgs = {
+    id: Scalars['ID']['input'];
+    versionId?: InputMaybe<Scalars['ID']['input']>;
+};
+export type QueryElementByKeyArgs = {
+    integrationId: Scalars['ID']['input'];
+    key: Scalars['ID']['input'];
+    type: ElementType;
+    versionId?: InputMaybe<Scalars['ID']['input']>;
+};
+export type QueryIntegrationArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryIntegrationByKeyArgs = {
+    accountId: Scalars['ID']['input'];
+    key: Scalars['ID']['input'];
+};
+export type QueryIntegrationsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    direction?: InputMaybe<Direction>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<IntegrationOrderField>;
+};
+export type QueryLogArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryLogEntryArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryNotificationsArgs = {
+    isAcknowledged?: InputMaybe<Scalars['Boolean']['input']>;
+};
+export type QueryThreadArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryUserArgs = {
+    id: Scalars['ID']['input'];
+};
+export type Response = {
+    __typename?: 'Response';
+    data?: Maybe<Scalars['JSON']['output']>;
+    error?: Maybe<Scalars['String']['output']>;
+    id: Scalars['String']['output'];
+    origin?: Maybe<Scalars['String']['output']>;
+    paging?: Maybe<ResponsePagination>;
+    params?: Maybe<Scalars['JSON']['output']>;
+    reason?: Maybe<Scalars['String']['output']>;
+    status: Scalars['String']['output'];
+    warning?: Maybe<Scalars['String']['output']>;
+};
+export type ResponsePagination = {
+    __typename?: 'ResponsePagination';
+    next?: Maybe<Scalars['JSON']['output']>;
+    prev?: Maybe<Scalars['JSON']['output']>;
+};
+export type RetryRule = Element & {
+    __typename?: 'RetryRule';
+    content?: Maybe<ElementContent>;
+    createdAt: Scalars['DateTime']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    key: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type Schema = Element & {
+    __typename?: 'Schema';
+    content?: Maybe<ElementContent>;
+    createdAt: Scalars['DateTime']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    key: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type SchemaMutation = Element & {
+    __typename?: 'SchemaMutation';
+    content?: Maybe<ElementContent>;
+    createdAt: Scalars['DateTime']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    key: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type Service = Element & {
+    __typename?: 'Service';
+    content?: Maybe<ElementContent>;
+    createdAt: Scalars['DateTime']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    key: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type Session = {
+    __typename?: 'Session';
+    accounts: Array<Account>;
+    user?: Maybe<User>;
+};
+export declare enum Status {
+    Active = "active",
+    Inactive = "inactive"
+}
+export type Thread = {
+    __typename?: 'Thread';
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    messages: MessageConnection;
+    participants: ParticipantConnection;
+    status: Status;
+    title: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type ThreadConnection = {
+    __typename?: 'ThreadConnection';
+    nodes: Array<Thread>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type User = {
+    __typename?: 'User';
+    createdAt: Scalars['DateTime']['output'];
+    email?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    roles: Array<Scalars['String']['output']>;
+    status: Status;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type UserConnection = {
+    __typename?: 'UserConnection';
+    nodes: Array<User>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type Value = Element & {
+    __typename?: 'Value';
+    content?: Maybe<ElementContent>;
+    createdAt: Scalars['DateTime']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    key: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+    value?: Maybe<Scalars['PrimitiveValue']['output']>;
+};
+export type Version = {
+    __typename?: 'Version';
+    auths: Array<Auth>;
+    config?: Maybe<ConfigElement>;
+    dictionaries: Array<Dictionary>;
+    elements: Array<Element>;
+    flows: Array<Flow>;
+    id: Scalars['ID']['output'];
+    isActive: Scalars['Boolean']['output'];
+    jobs: Array<Job>;
+    mutations: Array<SchemaMutation>;
+    name?: Maybe<Scalars['String']['output']>;
+    schemas: Array<Schema>;
+    services: Array<Service>;
+    timestamp: Scalars['DateTime']['output'];
+    values: Array<Value>;
+};
+export type VersionElementsArgs = {
+    type?: InputMaybe<Array<ElementType>>;
+};
+export type CreateAccountMutationVariables = Exact<{
+    name: Scalars['String']['input'];
+    key?: InputMaybe<Scalars['ID']['input']>;
+}>;
+export type CreateAccountMutation = {
+    __typename?: 'Mutation';
+    createAccount: {
+        __typename?: 'Account';
+        id: string;
+        key: string;
+        name: string;
+        createdAt: any;
+    };
+};
+export type AccountsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type AccountsQuery = {
+    __typename?: 'Query';
+    accounts?: {
+        __typename?: 'AccountConnection';
+        totalCount: number;
+        nodes: Array<{
+            __typename?: 'Account';
+            id: string;
+            name: string;
+            key: string;
+        }>;
+    } | null;
+};
+export type IntegrationDefinitionQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type IntegrationDefinitionQuery = {
+    __typename?: 'Query';
+    integration?: {
+        __typename?: 'Integration';
+        id: string;
+        key: string;
+        name: string;
+        description?: string | null;
+        status: Status;
+        account: {
+            __typename?: 'Account';
+            id: string;
+            key: string;
+            name: string;
+        };
+        latest: {
+            __typename?: 'Version';
+            timestamp: any;
+            elements: Array<{
+                __typename: 'Auth';
+                id: string;
+                key: string;
+                name: string;
+                content?: {
+                    __typename?: 'ElementContent';
+                    timestamp: any;
+                    data?: any | null;
+                } | null;
+            } | {
+                __typename: 'ConfigElement';
+                id: string;
+                key: string;
+                name: string;
+                content?: {
+                    __typename?: 'ElementContent';
+                    timestamp: any;
+                    data?: any | null;
+                } | null;
+            } | {
+                __typename: 'Dictionary';
+                id: string;
+                key: string;
+                name: string;
+                content?: {
+                    __typename?: 'ElementContent';
+                    timestamp: any;
+                    data?: any | null;
+                } | null;
+            } | {
+                __typename: 'Flow';
+                id: string;
+                key: string;
+                name: string;
+                content?: {
+                    __typename?: 'ElementContent';
+                    timestamp: any;
+                    data?: any | null;
+                } | null;
+            } | {
+                __typename: 'Job';
+                id: string;
+                key: string;
+                name: string;
+                content?: {
+                    __typename?: 'ElementContent';
+                    timestamp: any;
+                    data?: any | null;
+                } | null;
+            } | {
+                __typename: 'RetryRule';
+                id: string;
+                key: string;
+                name: string;
+                content?: {
+                    __typename?: 'ElementContent';
+                    timestamp: any;
+                    data?: any | null;
+                } | null;
+            } | {
+                __typename: 'Schema';
+                id: string;
+                key: string;
+                name: string;
+                content?: {
+                    __typename?: 'ElementContent';
+                    timestamp: any;
+                    data?: any | null;
+                } | null;
+            } | {
+                __typename: 'SchemaMutation';
+                id: string;
+                key: string;
+                name: string;
+                content?: {
+                    __typename?: 'ElementContent';
+                    timestamp: any;
+                    data?: any | null;
+                } | null;
+            } | {
+                __typename: 'Service';
+                id: string;
+                key: string;
+                name: string;
+                content?: {
+                    __typename?: 'ElementContent';
+                    timestamp: any;
+                    data?: any | null;
+                } | null;
+            } | {
+                __typename: 'Value';
+                id: string;
+                key: string;
+                name: string;
+                content?: {
+                    __typename?: 'ElementContent';
+                    timestamp: any;
+                    data?: any | null;
+                } | null;
+            }>;
+        };
+    } | null;
+};
+export type CreateVersionMutationVariables = Exact<{
+    integrationId: Scalars['ID']['input'];
+    name?: InputMaybe<Scalars['String']['input']>;
+    timestamp?: InputMaybe<Scalars['DateTime']['input']>;
+}>;
+export type CreateVersionMutation = {
+    __typename?: 'Mutation';
+    createVersion: {
+        __typename?: 'Version';
+        id: string;
+        name?: string | null;
+        timestamp: any;
+        isActive: boolean;
+    };
+};
+export type StartIntegrationMutationVariables = Exact<{
+    id: Scalars['ID']['input'];
+    versionId?: InputMaybe<Scalars['ID']['input']>;
+}>;
+export type StartIntegrationMutation = {
+    __typename?: 'Mutation';
+    startIntegration: {
+        __typename?: 'Integration';
+        id: string;
+        name: string;
+        status: Status;
+    };
+};
+export type CreateIntegrationMutationVariables = Exact<{
+    accountId: Scalars['ID']['input'];
+    name: Scalars['String']['input'];
+    key?: InputMaybe<Scalars['ID']['input']>;
+    description?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type CreateIntegrationMutation = {
+    __typename?: 'Mutation';
+    createIntegration: {
+        __typename?: 'Integration';
+        id: string;
+        key: string;
+        name: string;
+        createdAt: any;
+        description?: string | null;
+        status: Status;
+        account: {
+            __typename?: 'Account';
+            id: string;
+        };
+    };
+};
+export type IntegrationsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type IntegrationsQuery = {
+    __typename?: 'Query';
+    integrations: {
+        __typename?: 'IntegrationConnection';
+        totalCount: number;
+        nodes: Array<{
+            __typename?: 'Integration';
+            id: string;
+            name: string;
+            key: string;
+        }>;
+    };
+};
+export type IntegrationsForAccountQueryVariables = Exact<{
+    accountId: Scalars['ID']['input'];
+}>;
+export type IntegrationsForAccountQuery = {
+    __typename?: 'Query';
+    account?: {
+        __typename?: 'Account';
+        name: string;
+        integrations: {
+            __typename?: 'IntegrationConnection';
+            totalCount: number;
+            nodes: Array<{
+                __typename?: 'Integration';
+                id: string;
+                name: string;
+                key: string;
+            }>;
+        };
+    } | null;
+};
+export type IntegrationForPushQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type IntegrationForPushQuery = {
+    __typename?: 'Query';
+    integration?: {
+        __typename?: 'Integration';
+        id: string;
+        key: string;
+        name: string;
+        latest: {
+            __typename?: 'Version';
+            timestamp: any;
+            elements: Array<{
+                __typename: 'Auth';
+                id: string;
+                key: string;
+                name: string;
+                description?: string | null;
+                createdAt: any;
+                content?: {
+                    __typename?: 'ElementContent';
+                    checksum?: string | null;
+                    timestamp: any;
+                } | null;
+            } | {
+                __typename: 'ConfigElement';
+                id: string;
+                key: string;
+                name: string;
+                description?: string | null;
+                createdAt: any;
+                content?: {
+                    __typename?: 'ElementContent';
+                    checksum?: string | null;
+                    timestamp: any;
+                } | null;
+            } | {
+                __typename: 'Dictionary';
+                id: string;
+                key: string;
+                name: string;
+                description?: string | null;
+                createdAt: any;
+                content?: {
+                    __typename?: 'ElementContent';
+                    checksum?: string | null;
+                    timestamp: any;
+                } | null;
+            } | {
+                __typename: 'Flow';
+                id: string;
+                key: string;
+                name: string;
+                description?: string | null;
+                createdAt: any;
+                content?: {
+                    __typename?: 'ElementContent';
+                    checksum?: string | null;
+                    timestamp: any;
+                } | null;
+            } | {
+                __typename: 'Job';
+                id: string;
+                key: string;
+                name: string;
+                description?: string | null;
+                createdAt: any;
+                content?: {
+                    __typename?: 'ElementContent';
+                    checksum?: string | null;
+                    timestamp: any;
+                } | null;
+            } | {
+                __typename: 'RetryRule';
+                id: string;
+                key: string;
+                name: string;
+                description?: string | null;
+                createdAt: any;
+                content?: {
+                    __typename?: 'ElementContent';
+                    checksum?: string | null;
+                    timestamp: any;
+                } | null;
+            } | {
+                __typename: 'Schema';
+                id: string;
+                key: string;
+                name: string;
+                description?: string | null;
+                createdAt: any;
+                content?: {
+                    __typename?: 'ElementContent';
+                    checksum?: string | null;
+                    timestamp: any;
+                } | null;
+            } | {
+                __typename: 'SchemaMutation';
+                id: string;
+                key: string;
+                name: string;
+                description?: string | null;
+                createdAt: any;
+                content?: {
+                    __typename?: 'ElementContent';
+                    checksum?: string | null;
+                    timestamp: any;
+                } | null;
+            } | {
+                __typename: 'Service';
+                id: string;
+                key: string;
+                name: string;
+                description?: string | null;
+                createdAt: any;
+                content?: {
+                    __typename?: 'ElementContent';
+                    checksum?: string | null;
+                    timestamp: any;
+                } | null;
+            } | {
+                __typename: 'Value';
+                id: string;
+                key: string;
+                name: string;
+                description?: string | null;
+                createdAt: any;
+                content?: {
+                    __typename?: 'ElementContent';
+                    checksum?: string | null;
+                    timestamp: any;
+                } | null;
+            }>;
+        };
+    } | null;
+};
+export type CreateElementMutationVariables = Exact<{
+    integrationId: Scalars['ID']['input'];
+    key: Scalars['ID']['input'];
+    name: Scalars['String']['input'];
+    type: ElementType;
+    description?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type CreateElementMutation = {
+    __typename?: 'Mutation';
+    createElement: {
+        __typename?: 'Auth';
+        id: string;
+        key: string;
+    } | {
+        __typename?: 'ConfigElement';
+        id: string;
+        key: string;
+    } | {
+        __typename?: 'Dictionary';
+        id: string;
+        key: string;
+    } | {
+        __typename?: 'Flow';
+        id: string;
+        key: string;
+    } | {
+        __typename?: 'Job';
+        id: string;
+        key: string;
+    } | {
+        __typename?: 'RetryRule';
+        id: string;
+        key: string;
+    } | {
+        __typename?: 'Schema';
+        id: string;
+        key: string;
+    } | {
+        __typename?: 'SchemaMutation';
+        id: string;
+        key: string;
+    } | {
+        __typename?: 'Service';
+        id: string;
+        key: string;
+    } | {
+        __typename?: 'Value';
+        id: string;
+        key: string;
+    };
+};
+export type UpdateElementMutationVariables = Exact<{
+    id: Scalars['ID']['input'];
+    name?: InputMaybe<Scalars['String']['input']>;
+    description?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type UpdateElementMutation = {
+    __typename?: 'Mutation';
+    updateElement: {
+        __typename?: 'Auth';
+        id: string;
+        name: string;
+        description?: string | null;
+    } | {
+        __typename?: 'ConfigElement';
+        id: string;
+        name: string;
+        description?: string | null;
+    } | {
+        __typename?: 'Dictionary';
+        id: string;
+        name: string;
+        description?: string | null;
+    } | {
+        __typename?: 'Flow';
+        id: string;
+        name: string;
+        description?: string | null;
+    } | {
+        __typename?: 'Job';
+        id: string;
+        name: string;
+        description?: string | null;
+    } | {
+        __typename?: 'RetryRule';
+        id: string;
+        name: string;
+        description?: string | null;
+    } | {
+        __typename?: 'Schema';
+        id: string;
+        name: string;
+        description?: string | null;
+    } | {
+        __typename?: 'SchemaMutation';
+        id: string;
+        name: string;
+        description?: string | null;
+    } | {
+        __typename?: 'Service';
+        id: string;
+        name: string;
+        description?: string | null;
+    } | {
+        __typename?: 'Value';
+        id: string;
+        name: string;
+        description?: string | null;
+    };
+};
+export type SetElementContentMutationVariables = Exact<{
+    id: Scalars['ID']['input'];
+    content?: InputMaybe<Scalars['JSON']['input']>;
+}>;
+export type SetElementContentMutation = {
+    __typename?: 'Mutation';
+    setElementContent: {
+        __typename?: 'Auth';
+        id: string;
+        content?: {
+            __typename?: 'ElementContent';
+            timestamp: any;
+            checksum?: string | null;
+        } | null;
+    } | {
+        __typename?: 'ConfigElement';
+        id: string;
+        content?: {
+            __typename?: 'ElementContent';
+            timestamp: any;
+            checksum?: string | null;
+        } | null;
+    } | {
+        __typename?: 'Dictionary';
+        id: string;
+        content?: {
+            __typename?: 'ElementContent';
+            timestamp: any;
+            checksum?: string | null;
+        } | null;
+    } | {
+        __typename?: 'Flow';
+        id: string;
+        content?: {
+            __typename?: 'ElementContent';
+            timestamp: any;
+            checksum?: string | null;
+        } | null;
+    } | {
+        __typename?: 'Job';
+        id: string;
+        content?: {
+            __typename?: 'ElementContent';
+            timestamp: any;
+            checksum?: string | null;
+        } | null;
+    } | {
+        __typename?: 'RetryRule';
+        id: string;
+        content?: {
+            __typename?: 'ElementContent';
+            timestamp: any;
+            checksum?: string | null;
+        } | null;
+    } | {
+        __typename?: 'Schema';
+        id: string;
+        content?: {
+            __typename?: 'ElementContent';
+            timestamp: any;
+            checksum?: string | null;
+        } | null;
+    } | {
+        __typename?: 'SchemaMutation';
+        id: string;
+        content?: {
+            __typename?: 'ElementContent';
+            timestamp: any;
+            checksum?: string | null;
+        } | null;
+    } | {
+        __typename?: 'Service';
+        id: string;
+        content?: {
+            __typename?: 'ElementContent';
+            timestamp: any;
+            checksum?: string | null;
+        } | null;
+    } | {
+        __typename?: 'Value';
+        id: string;
+        content?: {
+            __typename?: 'ElementContent';
+            timestamp: any;
+            checksum?: string | null;
+        } | null;
+    };
+};
+export type DeleteElementMutationVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type DeleteElementMutation = {
+    __typename?: 'Mutation';
+    deleteElement: {
+        __typename?: 'Auth';
+        id: string;
+        key: string;
+    } | {
+        __typename?: 'ConfigElement';
+        id: string;
+        key: string;
+    } | {
+        __typename?: 'Dictionary';
+        id: string;
+        key: string;
+    } | {
+        __typename?: 'Flow';
+        id: string;
+        key: string;
+    } | {
+        __typename?: 'Job';
+        id: string;
+        key: string;
+    } | {
+        __typename?: 'RetryRule';
+        id: string;
+        key: string;
+    } | {
+        __typename?: 'Schema';
+        id: string;
+        key: string;
+    } | {
+        __typename?: 'SchemaMutation';
+        id: string;
+        key: string;
+    } | {
+        __typename?: 'Service';
+        id: string;
+        key: string;
+    } | {
+        __typename?: 'Value';
+        id: string;
+        key: string;
+    };
+};
+export type IntegrationElementsQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type IntegrationElementsQuery = {
+    __typename?: 'Query';
+    integration?: {
+        __typename?: 'Integration';
+        active?: {
+            __typename?: 'Version';
+            elements: Array<{
+                __typename: 'Auth';
+                id: string;
+                key: string;
+                name: string;
+                description?: string | null;
+            } | {
+                __typename: 'ConfigElement';
+                id: string;
+                key: string;
+                name: string;
+                description?: string | null;
+            } | {
+                __typename: 'Dictionary';
+                id: string;
+                key: string;
+                name: string;
+                description?: string | null;
+            } | {
+                __typename: 'Flow';
+                sort?: number | null;
+                id: string;
+                key: string;
+                name: string;
+                description?: string | null;
+            } | {
+                __typename: 'Job';
+                sort?: number | null;
+                isSubJob?: boolean | null;
+                id: string;
+                key: string;
+                name: string;
+                description?: string | null;
+            } | {
+                __typename: 'RetryRule';
+                id: string;
+                key: string;
+                name: string;
+                description?: string | null;
+            } | {
+                __typename: 'Schema';
+                id: string;
+                key: string;
+                name: string;
+                description?: string | null;
+            } | {
+                __typename: 'SchemaMutation';
+                id: string;
+                key: string;
+                name: string;
+                description?: string | null;
+            } | {
+                __typename: 'Service';
+                id: string;
+                key: string;
+                name: string;
+                description?: string | null;
+            } | {
+                __typename: 'Value';
+                id: string;
+                key: string;
+                name: string;
+                description?: string | null;
+            }>;
+        } | null;
+    } | null;
+};
+export type IntegrationStatusQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type IntegrationStatusQuery = {
+    __typename?: 'Query';
+    integration?: {
+        __typename?: 'Integration';
+        id: string;
+        key: string;
+        name: string;
+        status: Status;
+        active?: {
+            __typename?: 'Version';
+            id: string;
+            name?: string | null;
+            timestamp: any;
+        } | null;
+    } | null;
+};
+export type CreateIntegrationFromFileMutationVariables = Exact<{
+    accountId: Scalars['ID']['input'];
+    name: Scalars['String']['input'];
+    key?: InputMaybe<Scalars['ID']['input']>;
+    description?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type CreateIntegrationFromFileMutation = {
+    __typename?: 'Mutation';
+    createIntegration: {
+        __typename?: 'Integration';
+        id: string;
+        key: string;
+        name: string;
+        createdAt: any;
+        description?: string | null;
+        status: Status;
+        account: {
+            __typename?: 'Account';
+            id: string;
+            key: string;
+            name: string;
+        };
+    };
+};
+export type DispatchMutationVariables = Exact<{
+    integrationId: Scalars['ID']['input'];
+    type: Scalars['String']['input'];
+    payload: Scalars['JSON']['input'];
+    waitForResponse?: InputMaybe<Scalars['Boolean']['input']>;
+}>;
+export type DispatchMutation = {
+    __typename?: 'Mutation';
+    dispatch: {
+        __typename?: 'Response';
+        id: string;
+        status: string;
+        data?: any | null;
+        error?: string | null;
+        warning?: string | null;
+    };
+};
+export type SessionQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type SessionQuery = {
+    __typename?: 'Query';
+    session: {
+        __typename?: 'Session';
+        user?: {
+            __typename?: 'User';
+            id: string;
+            name: string;
+        } | null;
+    };
+};
+export type AccountByIdQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type AccountByIdQuery = {
+    __typename?: 'Query';
+    account?: {
+        __typename?: 'Account';
+        id: string;
+        name: string;
+        key: string;
+    } | null;
+};
+export type AccountByKeyQueryVariables = Exact<{
+    key: Scalars['ID']['input'];
+}>;
+export type AccountByKeyQuery = {
+    __typename?: 'Query';
+    accountByKey?: {
+        __typename?: 'Account';
+        id: string;
+        name: string;
+        key: string;
+    } | null;
+};
+export type ElementByIdQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type ElementByIdQuery = {
+    __typename?: 'Query';
+    element: {
+        __typename: 'Auth';
+        id: string;
+        key: string;
+        content?: {
+            __typename?: 'ElementContent';
+            data?: any | null;
+        } | null;
+    } | {
+        __typename: 'ConfigElement';
+        id: string;
+        key: string;
+        content?: {
+            __typename?: 'ElementContent';
+            data?: any | null;
+        } | null;
+    } | {
+        __typename: 'Dictionary';
+        id: string;
+        key: string;
+        content?: {
+            __typename?: 'ElementContent';
+            data?: any | null;
+        } | null;
+    } | {
+        __typename: 'Flow';
+        id: string;
+        key: string;
+        content?: {
+            __typename?: 'ElementContent';
+            data?: any | null;
+        } | null;
+    } | {
+        __typename: 'Job';
+        id: string;
+        key: string;
+        content?: {
+            __typename?: 'ElementContent';
+            data?: any | null;
+        } | null;
+    } | {
+        __typename: 'RetryRule';
+        id: string;
+        key: string;
+        content?: {
+            __typename?: 'ElementContent';
+            data?: any | null;
+        } | null;
+    } | {
+        __typename: 'Schema';
+        id: string;
+        key: string;
+        content?: {
+            __typename?: 'ElementContent';
+            data?: any | null;
+        } | null;
+    } | {
+        __typename: 'SchemaMutation';
+        id: string;
+        key: string;
+        content?: {
+            __typename?: 'ElementContent';
+            data?: any | null;
+        } | null;
+    } | {
+        __typename: 'Service';
+        id: string;
+        key: string;
+        content?: {
+            __typename?: 'ElementContent';
+            data?: any | null;
+        } | null;
+    } | {
+        __typename: 'Value';
+        value?: any | null;
+        id: string;
+        key: string;
+        content?: {
+            __typename?: 'ElementContent';
+            data?: any | null;
+        } | null;
+    };
+};
+export type ElementByKeyQueryVariables = Exact<{
+    integrationId: Scalars['ID']['input'];
+    key: Scalars['ID']['input'];
+    type: ElementType;
+}>;
+export type ElementByKeyQuery = {
+    __typename?: 'Query';
+    elementByKey: {
+        __typename: 'Auth';
+        id: string;
+        key: string;
+        content?: {
+            __typename?: 'ElementContent';
+            data?: any | null;
+        } | null;
+    } | {
+        __typename: 'ConfigElement';
+        id: string;
+        key: string;
+        content?: {
+            __typename?: 'ElementContent';
+            data?: any | null;
+        } | null;
+    } | {
+        __typename: 'Dictionary';
+        id: string;
+        key: string;
+        content?: {
+            __typename?: 'ElementContent';
+            data?: any | null;
+        } | null;
+    } | {
+        __typename: 'Flow';
+        id: string;
+        key: string;
+        content?: {
+            __typename?: 'ElementContent';
+            data?: any | null;
+        } | null;
+    } | {
+        __typename: 'Job';
+        id: string;
+        key: string;
+        content?: {
+            __typename?: 'ElementContent';
+            data?: any | null;
+        } | null;
+    } | {
+        __typename: 'RetryRule';
+        id: string;
+        key: string;
+        content?: {
+            __typename?: 'ElementContent';
+            data?: any | null;
+        } | null;
+    } | {
+        __typename: 'Schema';
+        id: string;
+        key: string;
+        content?: {
+            __typename?: 'ElementContent';
+            data?: any | null;
+        } | null;
+    } | {
+        __typename: 'SchemaMutation';
+        id: string;
+        key: string;
+        content?: {
+            __typename?: 'ElementContent';
+            data?: any | null;
+        } | null;
+    } | {
+        __typename: 'Service';
+        id: string;
+        key: string;
+        content?: {
+            __typename?: 'ElementContent';
+            data?: any | null;
+        } | null;
+    } | {
+        __typename: 'Value';
+        value?: any | null;
+        id: string;
+        key: string;
+        content?: {
+            __typename?: 'ElementContent';
+            data?: any | null;
+        } | null;
+    };
+};
+export type IntegrationQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type IntegrationQuery = {
+    __typename?: 'Query';
+    integration?: {
+        __typename?: 'Integration';
+        id: string;
+        name: string;
+    } | null;
+};
+export type IntegrationByKeyQueryVariables = Exact<{
+    accountId: Scalars['ID']['input'];
+    key: Scalars['ID']['input'];
+}>;
+export type IntegrationByKeyQuery = {
+    __typename?: 'Query';
+    integrationByKey?: {
+        __typename?: 'Integration';
+        id: string;
+        name: string;
+    } | null;
+};
+export type ValuesListQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type ValuesListQuery = {
+    __typename?: 'Query';
+    integration?: {
+        __typename?: 'Integration';
+        id: string;
+        key: string;
+        name: string;
+        latest: {
+            __typename?: 'Version';
+            elements: Array<{
+                __typename: 'Auth';
+            } | {
+                __typename: 'ConfigElement';
+            } | {
+                __typename: 'Dictionary';
+            } | {
+                __typename: 'Flow';
+            } | {
+                __typename: 'Job';
+            } | {
+                __typename: 'RetryRule';
+            } | {
+                __typename: 'Schema';
+            } | {
+                __typename: 'SchemaMutation';
+            } | {
+                __typename: 'Service';
+            } | {
+                __typename: 'Value';
+                id: string;
+                key: string;
+                name: string;
+                value?: any | null;
+                content?: {
+                    __typename?: 'ElementContent';
+                    data?: any | null;
+                } | null;
+            }>;
+        };
+    } | null;
+};
+export type SetValueMutationVariables = Exact<{
+    id: Scalars['ID']['input'];
+    value: Scalars['PrimitiveValue']['input'];
+}>;
+export type SetValueMutation = {
+    __typename?: 'Mutation';
+    setValue: boolean;
+};