great 1.0.2 → 1.2.0

package/dist/generated/schema.d.ts

@@ -0,0 +1,965 @@
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = T | null;
+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: string;
+        output: string;
+    };
+    DateTime: {
+        input: string;
+        output: string;
+    };
+    JSON: {
+        input: Record<string, unknown>;
+        output: Record<string, unknown>;
+    };
+    PrimitiveValue: {
+        input: unknown;
+        output: unknown;
+    };
+};
+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 Agent = {
+    __typename?: 'Agent';
+    activePrompt?: Maybe<Prompt>;
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    key: Scalars['String']['output'];
+    prompts: Array<Prompt>;
+    updatedAt: Scalars['DateTime']['output'];
+    user: User;
+};
+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']>;
+    createdAt: Scalars['DateTime']['output'];
+    data?: Maybe<Scalars['JSON']['output']>;
+    provenance: Array<Scalars['ID']['output']>;
+    sourceId?: Maybe<Scalars['ID']['output']>;
+    sourceTimestamp?: Maybe<Scalars['DateTime']['output']>;
+    timestamp?: Maybe<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>;
+    activeOrLatest: Version;
+    createdAt: Scalars['DateTime']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    hasChanges: Scalars['Boolean']['output'];
+    id: Scalars['ID']['output'];
+    key: Scalars['ID']['output'];
+    latest: Version;
+    logEntries: LogEntryConnection;
+    logs: LogConnection;
+    name: Scalars['String']['output'];
+    notifications: NotificationConnection;
+    status: Status;
+    templateImports: Array<TemplateImport>;
+    type: IntegrationType;
+    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 declare enum IntegrationType {
+    Integration = "integration",
+    Library = "library",
+    Template = "template"
+}
+export type Job = Element & {
+    __typename?: 'Job';
+    allowManualDispatch?: Maybe<Scalars['Boolean']['output']>;
+    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'];
+    data?: Maybe<Scalars['JSON']['output']>;
+    expireDataAt?: Maybe<Scalars['DateTime']['output']>;
+    id: Scalars['ID']['output'];
+    identId?: Maybe<Scalars['String']['output']>;
+    params?: Maybe<Scalars['JSON']['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",
+    Trigger = "trigger",
+    Unload = "unload"
+}
+export type Message = {
+    __typename?: 'Message';
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    isComplete: Scalars['Boolean']['output'];
+    message: Scalars['String']['output'];
+    model?: Maybe<Scalars['JSON']['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';
+    acknowledgeNotifications: Array<Notification>;
+    activateVersion: Integration;
+    addParticipant: Participant;
+    clearValue: Scalars['Boolean']['output'];
+    createAccount: Account;
+    createAgent: Agent;
+    createElement: Element;
+    createIntegration: Integration;
+    createPrompt: Prompt;
+    createRuleset: Ruleset;
+    createThread: Thread;
+    createUser: User;
+    createVersion: Version;
+    deleteAccount: Scalars['Boolean']['output'];
+    deleteElement: Element;
+    deleteIntegration: Scalars['Boolean']['output'];
+    deleteRuleset: Scalars['Boolean']['output'];
+    deleteThread: Thread;
+    dispatch: ResponseWithoutData;
+    importTemplate: Integration;
+    includeElement: Element;
+    postMessage: Message;
+    promotePrompt: Agent;
+    registerTemplateImport: Integration;
+    removeParticipant: Participant;
+    rollbackPrompt: Agent;
+    setElementContent: Element;
+    setSecretRef: Scalars['Boolean']['output'];
+    setValue: Scalars['Boolean']['output'];
+    startIntegration: Integration;
+    stopIntegration: Integration;
+    unacknowledgeNotifications: Array<Notification>;
+    updateAccountKey: Account;
+    updateAccountName: Account;
+    updateElement: Element;
+    updateElementKey: Element;
+    updateFromTemplate: Integration;
+    updateIntegration: Integration;
+    updateIntegrationKey: Integration;
+    updateIntegrationType: Integration;
+    updateRulesetName: Ruleset;
+    updateRulesetRules: Ruleset;
+    updateThreadTitle: Thread;
+    updateUserEmail: User;
+    updateUserName: User;
+    updateVersion: Version;
+};
+export type MutationAcknowledgeNotificationsArgs = {
+    ids: Array<Scalars['ID']['input']>;
+};
+export type MutationActivateVersionArgs = {
+    versionId: Scalars['ID']['input'];
+};
+export type MutationAddParticipantArgs = {
+    threadId: Scalars['ID']['input'];
+    userId: Scalars['ID']['input'];
+};
+export type MutationClearValueArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationCreateAccountArgs = {
+    key?: InputMaybe<Scalars['ID']['input']>;
+    name: Scalars['String']['input'];
+};
+export type MutationCreateAgentArgs = {
+    key: Scalars['String']['input'];
+    userId: Scalars['ID']['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'];
+    type?: InputMaybe<IntegrationType>;
+};
+export type MutationCreatePromptArgs = {
+    agentId: Scalars['ID']['input'];
+    content: Scalars['String']['input'];
+    parentVersionId?: InputMaybe<Scalars['ID']['input']>;
+};
+export type MutationCreateRulesetArgs = {
+    name: Scalars['String']['input'];
+    rules?: InputMaybe<Array<RuleInput>>;
+};
+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 MutationDeleteRulesetArgs = {
+    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 MutationImportTemplateArgs = {
+    integrationId: Scalars['ID']['input'];
+    templateId: Scalars['ID']['input'];
+    versionId?: InputMaybe<Scalars['ID']['input']>;
+};
+export type MutationIncludeElementArgs = {
+    elementId: Scalars['ID']['input'];
+    integrationId: Scalars['ID']['input'];
+    provenance?: InputMaybe<Array<Scalars['ID']['input']>>;
+    sourceTimestamp?: InputMaybe<Scalars['DateTime']['input']>;
+};
+export type MutationPostMessageArgs = {
+    message: Scalars['String']['input'];
+    threadId: Scalars['ID']['input'];
+};
+export type MutationPromotePromptArgs = {
+    agentId: Scalars['ID']['input'];
+    promptId: Scalars['ID']['input'];
+};
+export type MutationRegisterTemplateImportArgs = {
+    integrationId: Scalars['ID']['input'];
+    templateId: Scalars['ID']['input'];
+    timestamp: Scalars['DateTime']['input'];
+};
+export type MutationRemoveParticipantArgs = {
+    threadId: Scalars['ID']['input'];
+    userId: Scalars['ID']['input'];
+};
+export type MutationRollbackPromptArgs = {
+    agentId: Scalars['ID']['input'];
+    promptId: Scalars['ID']['input'];
+};
+export type MutationSetElementContentArgs = {
+    content?: InputMaybe<Scalars['JSON']['input']>;
+    id: Scalars['ID']['input'];
+};
+export type MutationSetSecretRefArgs = {
+    id: Scalars['ID']['input'];
+    secretRef: Scalars['String']['input'];
+};
+export type MutationSetValueArgs = {
+    id: Scalars['ID']['input'];
+    value?: InputMaybe<Scalars['PrimitiveValue']['input']>;
+};
+export type MutationStartIntegrationArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationStopIntegrationArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationUnacknowledgeNotificationsArgs = {
+    ids: Array<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 MutationUpdateFromTemplateArgs = {
+    integrationId: Scalars['ID']['input'];
+    templateId: Scalars['ID']['input'];
+    versionId?: InputMaybe<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 MutationUpdateIntegrationTypeArgs = {
+    id: Scalars['ID']['input'];
+    type: IntegrationType;
+};
+export type MutationUpdateRulesetNameArgs = {
+    id: Scalars['ID']['input'];
+    name: Scalars['String']['input'];
+};
+export type MutationUpdateRulesetRulesArgs = {
+    id: Scalars['ID']['input'];
+    rules: Array<RuleInput>;
+};
+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 Prompt = {
+    __typename?: 'Prompt';
+    content: Scalars['String']['output'];
+    createdAt: Scalars['DateTime']['output'];
+    creator: User;
+    id: Scalars['ID']['output'];
+    parentVersion?: Maybe<Prompt>;
+};
+export type Query = {
+    __typename?: 'Query';
+    account?: Maybe<Account>;
+    accountByKey?: Maybe<Account>;
+    accounts?: Maybe<AccountConnection>;
+    agent?: Maybe<Agent>;
+    agentByKey?: Maybe<Agent>;
+    agents: Array<Agent>;
+    element: Element;
+    elementByKey: Element;
+    integration?: Maybe<Integration>;
+    integrationByKey?: Maybe<Integration>;
+    integrations: IntegrationConnection;
+    log: Log;
+    logEntry: LogEntry;
+    notifications: NotificationConnection;
+    resolveElementInclude: ResolvedShadowElement;
+    resolveTemplateImport: ResolvedTemplateImport;
+    response?: Maybe<Response>;
+    ruleset?: Maybe<Ruleset>;
+    rulesets: RulesetConnection;
+    secretRef?: Maybe<Scalars['String']['output']>;
+    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 QueryAgentArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryAgentByKeyArgs = {
+    key: Scalars['String']['input'];
+};
+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 = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    isAcknowledged?: InputMaybe<Scalars['Boolean']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+};
+export type QueryResolveElementIncludeArgs = {
+    elementId: Scalars['ID']['input'];
+    sourceTimestamp?: InputMaybe<Scalars['DateTime']['input']>;
+};
+export type QueryResolveTemplateImportArgs = {
+    templateId: Scalars['ID']['input'];
+    versionId?: InputMaybe<Scalars['ID']['input']>;
+};
+export type QueryResponseArgs = {
+    actionId: Scalars['ID']['input'];
+};
+export type QueryRulesetArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryRulesetsArgs = {
+    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<RulesetOrderField>;
+};
+export type QuerySecretRefArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryThreadArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryUserArgs = {
+    id: Scalars['ID']['input'];
+};
+export type ResolvedShadowElement = {
+    __typename?: 'ResolvedShadowElement';
+    content?: Maybe<ElementContent>;
+    description?: Maybe<Scalars['String']['output']>;
+    key: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    type: ElementType;
+};
+export type ResolvedTemplateImport = {
+    __typename?: 'ResolvedTemplateImport';
+    elements: Array<ResolvedShadowElement>;
+    timestamp: Scalars['DateTime']['output'];
+};
+export type Response = {
+    __typename?: 'Response';
+    data?: Maybe<Scalars['JSON']['output']>;
+    error?: Maybe<Scalars['String']['output']>;
+    expireDataAt?: Maybe<Scalars['DateTime']['output']>;
+    id: Scalars['String']['output'];
+    itemCount?: Maybe<Scalars['Int']['output']>;
+    origin?: Maybe<Scalars['String']['output']>;
+    paging?: Maybe<ResponsePagination>;
+    params?: Maybe<Scalars['JSON']['output']>;
+    reason?: Maybe<Scalars['String']['output']>;
+    status: Scalars['String']['output'];
+    unitCount?: Maybe<Scalars['Int']['output']>;
+    warning?: Maybe<Scalars['String']['output']>;
+};
+export type ResponsePagination = {
+    __typename?: 'ResponsePagination';
+    next?: Maybe<Scalars['JSON']['output']>;
+    prev?: Maybe<Scalars['JSON']['output']>;
+};
+export type ResponseWithoutData = {
+    __typename?: 'ResponseWithoutData';
+    error?: Maybe<Scalars['String']['output']>;
+    id: Scalars['String']['output'];
+    itemCount?: Maybe<Scalars['Int']['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 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 Rule = {
+    __typename?: 'Rule';
+    conditions: Array<Scalars['JSON']['output']>;
+    response: RuleResponse;
+};
+export type RuleInput = {
+    conditions: Array<Scalars['JSON']['input']>;
+    response: RuleResponseInput;
+};
+export type RuleResponse = {
+    __typename?: 'RuleResponse';
+    body?: Maybe<Scalars['JSON']['output']>;
+    headers?: Maybe<Scalars['JSON']['output']>;
+    status: Scalars['Int']['output'];
+};
+export type RuleResponseInput = {
+    body?: InputMaybe<Scalars['JSON']['input']>;
+    headers?: InputMaybe<Scalars['JSON']['input']>;
+    status: Scalars['Int']['input'];
+};
+export type Ruleset = {
+    __typename?: 'Ruleset';
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    rules: Array<Rule>;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type RulesetConnection = {
+    __typename?: 'RulesetConnection';
+    nodes: Array<Ruleset>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export declare enum RulesetOrderField {
+    CreatedAt = "createdAt",
+    Name = "name",
+    UpdatedAt = "updatedAt"
+}
+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 Subscription = {
+    __typename?: 'Subscription';
+    messagePosted: Message;
+};
+export type SubscriptionMessagePostedArgs = {
+    threadId: Scalars['ID']['input'];
+};
+export type TemplateImport = {
+    __typename?: 'TemplateImport';
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    template?: Maybe<Integration>;
+    timestamp: Scalars['DateTime']['output'];
+};
+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;
+    type: UserType;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type UserConnection = {
+    __typename?: 'UserConnection';
+    nodes: Array<User>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export declare enum UserType {
+    Agent = "agent",
+    Support = "support",
+    User = "user"
+}
+export type Value = Element & {
+    __typename?: 'Value';
+    content?: Maybe<ElementContent>;
+    createdAt: Scalars['DateTime']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    hasValue: Scalars['Boolean']['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>>;
+};