@appkit/dek-lib 0.1.0

package/dist/data/types/graphql.d.ts

@@ -0,0 +1,1283 @@
+import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+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;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+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;
+    };
+    /** The DateTime scalar type represents date time strings complying to ISO-8601. */
+    DateTime: {
+        input: any;
+        output: any;
+    };
+};
+export type AddAuthorInput = {
+    email: Scalars['String']['input'];
+    name: Scalars['String']['input'];
+    ssn?: InputMaybe<Scalars['String']['input']>;
+};
+export type AddAuthorResult = {
+    __typename?: 'AddAuthorResult';
+    author?: Maybe<Author>;
+    error?: Maybe<Error>;
+};
+export type AddBoardInput = {
+    key: Scalars['ID']['input'];
+    layout: Scalars['String']['input'];
+    title: Scalars['String']['input'];
+};
+export type AddBoardResult = {
+    __typename?: 'AddBoardResult';
+    board?: Maybe<Board>;
+    error?: Maybe<Error>;
+};
+export type AddBookInput = {
+    abstract: Scalars['String']['input'];
+    authorId: Scalars['ID']['input'];
+    coverImageUrl?: InputMaybe<Scalars['String']['input']>;
+    publishedAt: Scalars['DateTime']['input'];
+    title: Scalars['String']['input'];
+};
+export type AddBookResult = {
+    __typename?: 'AddBookResult';
+    book?: Maybe<Book>;
+    error?: Maybe<Error>;
+};
+export type AddCommandGroupInput = {
+    commandIds: Array<Scalars['String']['input']>;
+    key: Scalars['String']['input'];
+    title: Scalars['String']['input'];
+};
+export type AddCommandGroupResult = {
+    __typename?: 'AddCommandGroupResult';
+    commandGroup?: Maybe<CommandGroup>;
+    error?: Maybe<Error>;
+};
+export type AddCommandInput = {
+    component: Scalars['String']['input'];
+    containerProps?: InputMaybe<Array<CommandPropInput>>;
+    plugin: Scalars['String']['input'];
+    props?: InputMaybe<Array<CommandPropInput>>;
+    title: Scalars['String']['input'];
+};
+export type AddCommandResult = {
+    __typename?: 'AddCommandResult';
+    command?: Maybe<Command>;
+    error?: Maybe<Error>;
+};
+export type AddIntegrationInput = {
+    key: Scalars['String']['input'];
+    pluginConfig?: InputMaybe<Array<PluginConfigInput>>;
+    pluginName: Scalars['String']['input'];
+    pluginVersion?: InputMaybe<Scalars['String']['input']>;
+    title: Scalars['String']['input'];
+};
+export type AddIntegrationResult = {
+    __typename?: 'AddIntegrationResult';
+    error?: Maybe<Error>;
+    integration?: Maybe<Integration>;
+};
+export type AddLayoutInput = {
+    content: Scalars['String']['input'];
+    title: Scalars['String']['input'];
+};
+export type AddLayoutResult = {
+    __typename?: 'AddLayoutResult';
+    error?: Maybe<Error>;
+    layout?: Maybe<Layout>;
+};
+export type AddPluginInput = {
+    author: Scalars['String']['input'];
+    code: Scalars['String']['input'];
+    components: Array<PluginComponentInput>;
+    description: Scalars['String']['input'];
+    name: Scalars['String']['input'];
+    private?: Scalars['Boolean']['input'];
+    version: Scalars['String']['input'];
+};
+export type AddPluginResult = {
+    __typename?: 'AddPluginResult';
+    error?: Maybe<Error>;
+    plugin?: Maybe<Plugin>;
+};
+export type AddProductInput = {
+    active: Scalars['Boolean']['input'];
+    adjustmentAmount?: InputMaybe<Scalars['Float']['input']>;
+    adjustmentType?: InputMaybe<Scalars['String']['input']>;
+    availableForBooking: Scalars['Boolean']['input'];
+    billingResponsibility: BillingResponsibility;
+    clientKeys: Array<Scalars['String']['input']>;
+    descriptionPrivate?: InputMaybe<Scalars['String']['input']>;
+    descriptionPublic?: InputMaybe<Scalars['String']['input']>;
+    listPrice: Scalars['Float']['input'];
+    name?: InputMaybe<Scalars['String']['input']>;
+    notes?: InputMaybe<Scalars['String']['input']>;
+    requiresPaymentMethod: Scalars['Boolean']['input'];
+    sku: Scalars['String']['input'];
+    wholesalePrice: Scalars['Float']['input'];
+};
+export type AddProductResult = {
+    __typename?: 'AddProductResult';
+    error?: Maybe<Error>;
+    product?: Maybe<Product>;
+};
+export type AddUserInput = {
+    avatar?: InputMaybe<Scalars['String']['input']>;
+    email: Scalars['String']['input'];
+    location?: InputMaybe<Scalars['String']['input']>;
+    name: Scalars['String']['input'];
+    password: Scalars['String']['input'];
+};
+export type AddUserResult = {
+    __typename?: 'AddUserResult';
+    error?: Maybe<Error>;
+    user?: Maybe<User>;
+};
+export type AddZoneInput = {
+    boardId: Scalars['ID']['input'];
+    component: Scalars['String']['input'];
+    containerProps?: InputMaybe<Array<ZonePropInput>>;
+    key: Scalars['String']['input'];
+    plugin: Scalars['String']['input'];
+    props?: InputMaybe<Array<ZonePropInput>>;
+};
+export type AddZoneResult = {
+    __typename?: 'AddZoneResult';
+    error?: Maybe<Error>;
+    zone?: Maybe<Zone>;
+};
+export type Auth = {
+    __typename?: 'Auth';
+    id: Scalars['ID']['output'];
+    name?: Maybe<Scalars['String']['output']>;
+    roles: Array<AuthRole>;
+};
+export declare enum AuthRole {
+    Admin = "ADMIN",
+    Delete = "DELETE",
+    Read = "READ",
+    ReadSensitive = "READ_SENSITIVE",
+    User = "USER",
+    Write = "WRITE"
+}
+export type Author = {
+    __typename?: 'Author';
+    archived: Scalars['Boolean']['output'];
+    archivedAt?: Maybe<Scalars['DateTime']['output']>;
+    books: BooksResult;
+    createdAt: Scalars['DateTime']['output'];
+    email: Scalars['String']['output'];
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    ssn?: Maybe<Scalars['String']['output']>;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type AuthorBooksArgs = {
+    order?: InputMaybe<Array<OrderByInput>>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    perPage?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<AuthorBooksQueryInput>;
+};
+export type AuthorBooksQueryInput = {
+    abstract?: InputMaybe<RegexExpressionInput>;
+    archived?: InputMaybe<YesNoAnyInput>;
+    createdAt?: InputMaybe<DateRangeInput>;
+    publishedAt?: InputMaybe<DateRangeInput>;
+    title?: InputMaybe<RegexExpressionInput>;
+    updatedAt?: InputMaybe<DateRangeInput>;
+};
+export type AuthorChangeResult = {
+    __typename?: 'AuthorChangeResult';
+    action: ChangeAction;
+    author?: Maybe<Author>;
+    id: Scalars['ID']['output'];
+};
+export type AuthorsQueryInput = {
+    archived?: InputMaybe<YesNoAnyInput>;
+    createdAt?: InputMaybe<DateRangeInput>;
+    email?: InputMaybe<RegexExpressionInput>;
+    name?: InputMaybe<RegexExpressionInput>;
+    ssn?: InputMaybe<RegexExpressionInput>;
+    updatedAt?: InputMaybe<DateRangeInput>;
+};
+export type AuthorsResult = {
+    __typename?: 'AuthorsResult';
+    info: QueryInfo;
+    nodes: Array<Author>;
+};
+export declare enum BillingResponsibility {
+    Broker = "BROKER",
+    Customer = "CUSTOMER"
+}
+export type Board = {
+    __typename?: 'Board';
+    archived: Scalars['Boolean']['output'];
+    archivedAt?: Maybe<Scalars['DateTime']['output']>;
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    key: Scalars['ID']['output'];
+    layout?: Maybe<Scalars['String']['output']>;
+    title: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+    user: User;
+    zones: Array<Zone>;
+};
+export type BoardChangeResult = {
+    __typename?: 'BoardChangeResult';
+    action: ChangeAction;
+    board?: Maybe<Board>;
+    id: Scalars['ID']['output'];
+};
+export type BoardsQueryInput = {
+    archived?: InputMaybe<YesNoAnyInput>;
+    createdAt?: InputMaybe<DateRangeInput>;
+    layout?: InputMaybe<RegexExpressionInput>;
+    title?: InputMaybe<RegexExpressionInput>;
+    updatedAt?: InputMaybe<DateRangeInput>;
+};
+export type BoardsResult = {
+    __typename?: 'BoardsResult';
+    info: QueryInfo;
+    nodes: Array<Board>;
+};
+export type Book = {
+    __typename?: 'Book';
+    abstract: Scalars['String']['output'];
+    archived: Scalars['Boolean']['output'];
+    archivedAt?: Maybe<Scalars['DateTime']['output']>;
+    author: Author;
+    coverImageUrl?: Maybe<Scalars['String']['output']>;
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    publishedAt: Scalars['DateTime']['output'];
+    title: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type BookChangeResult = {
+    __typename?: 'BookChangeResult';
+    action: ChangeAction;
+    book?: Maybe<Book>;
+    id: Scalars['ID']['output'];
+};
+export type BooksQueryInput = {
+    abstract?: InputMaybe<RegexExpressionInput>;
+    archived?: InputMaybe<YesNoAnyInput>;
+    authorIds?: InputMaybe<Array<InputMaybe<Scalars['ID']['input']>>>;
+    createdAt?: InputMaybe<DateRangeInput>;
+    publishedAt?: InputMaybe<DateRangeInput>;
+    title?: InputMaybe<RegexExpressionInput>;
+    updatedAt?: InputMaybe<DateRangeInput>;
+};
+export type BooksResult = {
+    __typename?: 'BooksResult';
+    info: QueryInfo;
+    nodes: Array<Book>;
+};
+export declare enum ChangeAction {
+    Created = "CREATED",
+    Deleted = "DELETED",
+    Updated = "UPDATED"
+}
+export type Command = {
+    __typename?: 'Command';
+    archived: Scalars['Boolean']['output'];
+    archivedAt?: Maybe<Scalars['DateTime']['output']>;
+    component: Scalars['String']['output'];
+    containerProps: Array<CommandProp>;
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    plugin: Scalars['String']['output'];
+    props: Array<CommandProp>;
+    title: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+    user: User;
+};
+export type CommandChangeResult = {
+    __typename?: 'CommandChangeResult';
+    action: ChangeAction;
+    command?: Maybe<Command>;
+    id: Scalars['ID']['output'];
+};
+export type CommandGroup = {
+    __typename?: 'CommandGroup';
+    archived: Scalars['Boolean']['output'];
+    archivedAt?: Maybe<Scalars['DateTime']['output']>;
+    commands: Array<Command>;
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    key: Scalars['String']['output'];
+    title: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+    user: User;
+};
+export type CommandGroupChangeResult = {
+    __typename?: 'CommandGroupChangeResult';
+    action: ChangeAction;
+    commandGroup?: Maybe<CommandGroup>;
+    id: Scalars['ID']['output'];
+};
+export type CommandGroupsQueryInput = {
+    archived?: InputMaybe<YesNoAnyInput>;
+    createdAt?: InputMaybe<DateRangeInput>;
+    publishedAt?: InputMaybe<DateRangeInput>;
+    updatedAt?: InputMaybe<DateRangeInput>;
+};
+export type CommandGroupsResult = {
+    __typename?: 'CommandGroupsResult';
+    info: QueryInfo;
+    nodes: Array<CommandGroup>;
+};
+export type CommandProp = {
+    __typename?: 'CommandProp';
+    key: Scalars['String']['output'];
+    value: Scalars['String']['output'];
+};
+export type CommandPropInput = {
+    key: Scalars['String']['input'];
+    value: Scalars['String']['input'];
+};
+export type CommandsQueryInput = {
+    archived?: InputMaybe<YesNoAnyInput>;
+    createdAt?: InputMaybe<DateRangeInput>;
+    title?: InputMaybe<RegexExpressionInput>;
+    updatedAt?: InputMaybe<DateRangeInput>;
+};
+export type CommandsResult = {
+    __typename?: 'CommandsResult';
+    info: QueryInfo;
+    nodes: Array<Command>;
+};
+export type DateRangeInput = {
+    days?: InputMaybe<Scalars['Int']['input']>;
+    end?: InputMaybe<Scalars['DateTime']['input']>;
+    start: Scalars['DateTime']['input'];
+};
+export type DeleteAuthorResult = {
+    __typename?: 'DeleteAuthorResult';
+    id: Scalars['ID']['output'];
+};
+export type DeleteBoardResult = {
+    __typename?: 'DeleteBoardResult';
+    id: Scalars['ID']['output'];
+};
+export type DeleteBookResult = {
+    __typename?: 'DeleteBookResult';
+    id: Scalars['ID']['output'];
+};
+export type DeleteCommandGroupResult = {
+    __typename?: 'DeleteCommandGroupResult';
+    id: Scalars['ID']['output'];
+};
+export type DeleteCommandResult = {
+    __typename?: 'DeleteCommandResult';
+    id: Scalars['ID']['output'];
+};
+export type DeleteIntegrationResult = {
+    __typename?: 'DeleteIntegrationResult';
+    id: Scalars['ID']['output'];
+};
+export type DeleteLayoutResult = {
+    __typename?: 'DeleteLayoutResult';
+    id: Scalars['ID']['output'];
+};
+export type DeleteProductResult = {
+    __typename?: 'DeleteProductResult';
+    id: Scalars['ID']['output'];
+};
+export type DeleteUserResult = {
+    __typename?: 'DeleteUserResult';
+    id: Scalars['ID']['output'];
+};
+export type DeleteZoneResult = {
+    __typename?: 'DeleteZoneResult';
+    id: Scalars['ID']['output'];
+};
+export type Error = {
+    __typename?: 'Error';
+    message: Scalars['String']['output'];
+};
+export type ImageDataResult = {
+    __typename?: 'ImageDataResult';
+    error?: Maybe<Error>;
+    input?: Maybe<Scalars['String']['output']>;
+};
+export type Integration = {
+    __typename?: 'Integration';
+    archived: Scalars['Boolean']['output'];
+    archivedAt?: Maybe<Scalars['DateTime']['output']>;
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    key: Scalars['String']['output'];
+    pluginConfig: Array<PluginConfig>;
+    pluginName: Scalars['String']['output'];
+    pluginVersion?: Maybe<Scalars['String']['output']>;
+    title: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+    user: User;
+};
+export type IntegrationChangeResult = {
+    __typename?: 'IntegrationChangeResult';
+    action: ChangeAction;
+    id: Scalars['ID']['output'];
+    integration?: Maybe<Integration>;
+};
+export type IntegrationsQueryInput = {
+    archived?: InputMaybe<YesNoAnyInput>;
+    createdAt?: InputMaybe<DateRangeInput>;
+    pluginName?: InputMaybe<RegexExpressionInput>;
+    pluginVersion?: InputMaybe<RegexExpressionInput>;
+    title?: InputMaybe<RegexExpressionInput>;
+    updatedAt?: InputMaybe<DateRangeInput>;
+};
+export type IntegrationsResult = {
+    __typename?: 'IntegrationsResult';
+    info: QueryInfo;
+    nodes: Array<Integration>;
+};
+export type Layout = {
+    __typename?: 'Layout';
+    archived: Scalars['Boolean']['output'];
+    archivedAt?: Maybe<Scalars['DateTime']['output']>;
+    content: Scalars['String']['output'];
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    shared: Scalars['Boolean']['output'];
+    title: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+    user: User;
+};
+export type LayoutChangeResult = {
+    __typename?: 'LayoutChangeResult';
+    action: ChangeAction;
+    id: Scalars['ID']['output'];
+    layout?: Maybe<Layout>;
+};
+export type LayoutsQueryInput = {
+    archived?: InputMaybe<YesNoAnyInput>;
+    createdAt?: InputMaybe<DateRangeInput>;
+    shared?: InputMaybe<YesNoAnyInput>;
+    updatedAt?: InputMaybe<DateRangeInput>;
+};
+export type LayoutsResult = {
+    __typename?: 'LayoutsResult';
+    info: QueryInfo;
+    nodes: Array<Layout>;
+};
+export type LoginResult = {
+    __typename?: 'LoginResult';
+    error?: Maybe<Error>;
+    token?: Maybe<Scalars['String']['output']>;
+};
+export type Mutation = {
+    __typename?: 'Mutation';
+    addAuthor: AddAuthorResult;
+    addBoard: AddBoardResult;
+    addBook: AddBookResult;
+    addCommand: AddCommandResult;
+    addCommandGroup: AddCommandGroupResult;
+    addIntegration: AddIntegrationResult;
+    addLayout: AddLayoutResult;
+    addPlugin: AddPluginResult;
+    addProduct: AddProductResult;
+    addUser: AddUserResult;
+    addZone: AddZoneResult;
+    deleteAuthor: DeleteAuthorResult;
+    deleteBoard: DeleteBoardResult;
+    deleteBook: DeleteBookResult;
+    deleteCommand: DeleteCommandResult;
+    deleteCommandGroup: DeleteCommandGroupResult;
+    deleteIntegration: DeleteIntegrationResult;
+    deleteLayout: DeleteLayoutResult;
+    deleteProduct: DeleteProductResult;
+    deleteUser: DeleteUserResult;
+    deleteZone: DeleteZoneResult;
+    login: LoginResult;
+    register: RegisterResult;
+    updateAuthor: UpdateAuthorResult;
+    updateBoard: UpdateBoardResult;
+    updateBook: UpdateBookResult;
+    updateCommand: UpdateCommandResult;
+    updateCommandGroup: UpdateCommandGroupResult;
+    updateIntegration: UpdateIntegrationResult;
+    updateLayout: UpdateLayoutResult;
+    updateProduct: UpdateProductResult;
+    updateUser: UpdateUserResult;
+    updateUserConfig: UpdateUserConfigResult;
+    updateZone: UpdateZoneResult;
+};
+export type MutationAddAuthorArgs = {
+    input: AddAuthorInput;
+};
+export type MutationAddBoardArgs = {
+    input: AddBoardInput;
+};
+export type MutationAddBookArgs = {
+    input: AddBookInput;
+};
+export type MutationAddCommandArgs = {
+    input: AddCommandInput;
+};
+export type MutationAddCommandGroupArgs = {
+    input: AddCommandGroupInput;
+};
+export type MutationAddIntegrationArgs = {
+    input: AddIntegrationInput;
+};
+export type MutationAddLayoutArgs = {
+    input: AddLayoutInput;
+};
+export type MutationAddPluginArgs = {
+    input: AddPluginInput;
+};
+export type MutationAddProductArgs = {
+    input: AddProductInput;
+};
+export type MutationAddUserArgs = {
+    input: AddUserInput;
+};
+export type MutationAddZoneArgs = {
+    input: AddZoneInput;
+};
+export type MutationDeleteAuthorArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteBoardArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteBookArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteCommandArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteCommandGroupArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteIntegrationArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteLayoutArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteProductArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteUserArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteZoneArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationLoginArgs = {
+    email: Scalars['String']['input'];
+    password: Scalars['String']['input'];
+};
+export type MutationRegisterArgs = {
+    email: Scalars['String']['input'];
+    name: Scalars['String']['input'];
+    password: Scalars['String']['input'];
+};
+export type MutationUpdateAuthorArgs = {
+    id: Scalars['ID']['input'];
+    input: UpdateAuthorInput;
+};
+export type MutationUpdateBoardArgs = {
+    id: Scalars['ID']['input'];
+    input: UpdateBoardInput;
+};
+export type MutationUpdateBookArgs = {
+    id: Scalars['ID']['input'];
+    input: UpdateBookInput;
+};
+export type MutationUpdateCommandArgs = {
+    id: Scalars['ID']['input'];
+    input: UpdateCommandInput;
+};
+export type MutationUpdateCommandGroupArgs = {
+    id: Scalars['ID']['input'];
+    input: UpdateCommandGroupInput;
+};
+export type MutationUpdateIntegrationArgs = {
+    id: Scalars['ID']['input'];
+    input: UpdateIntegrationInput;
+};
+export type MutationUpdateLayoutArgs = {
+    id: Scalars['ID']['input'];
+    input: UpdateLayoutInput;
+};
+export type MutationUpdateProductArgs = {
+    id: Scalars['ID']['input'];
+    input: UpdateProductInput;
+};
+export type MutationUpdateUserArgs = {
+    id: Scalars['ID']['input'];
+    input: UpdateUserInput;
+};
+export type MutationUpdateUserConfigArgs = {
+    input: UpdateUserConfigInput;
+};
+export type MutationUpdateZoneArgs = {
+    id: Scalars['ID']['input'];
+    input: UpdateZoneInput;
+};
+export type OrderBy = {
+    __typename?: 'OrderBy';
+    direction?: Maybe<OrderDirection>;
+    field: Scalars['String']['output'];
+};
+export type OrderByInput = {
+    direction?: InputMaybe<OrderDirection>;
+    field: Scalars['String']['input'];
+};
+export declare enum OrderDirection {
+    Asc = "ASC",
+    Desc = "DESC"
+}
+export type Plugin = {
+    __typename?: 'Plugin';
+    archived: Scalars['Boolean']['output'];
+    archivedAt?: Maybe<Scalars['DateTime']['output']>;
+    author: Scalars['String']['output'];
+    code: Scalars['String']['output'];
+    components: Array<PluginComponent>;
+    createdAt: Scalars['DateTime']['output'];
+    description: Scalars['String']['output'];
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    private: Scalars['Boolean']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+    user: User;
+    version: Scalars['String']['output'];
+};
+export type PluginChangeResult = {
+    __typename?: 'PluginChangeResult';
+    action: ChangeAction;
+    id: Scalars['ID']['output'];
+    plugin?: Maybe<Plugin>;
+};
+export type PluginComponent = {
+    __typename?: 'PluginComponent';
+    description: Scalars['String']['output'];
+    key: Scalars['String']['output'];
+    name: Scalars['String']['output'];
+};
+export type PluginComponentInput = {
+    description: Scalars['String']['input'];
+    key: Scalars['String']['input'];
+    name: Scalars['String']['input'];
+};
+export type PluginConfig = {
+    __typename?: 'PluginConfig';
+    key: Scalars['String']['output'];
+    value: Scalars['String']['output'];
+};
+export type PluginConfigInput = {
+    key: Scalars['String']['input'];
+    value: Scalars['String']['input'];
+};
+export type PluginsQueryInput = {
+    archived?: InputMaybe<YesNoAnyInput>;
+    author?: InputMaybe<RegexExpressionInput>;
+    createdAt?: InputMaybe<DateRangeInput>;
+    name?: InputMaybe<RegexExpressionInput>;
+    private?: InputMaybe<YesNoAnyInput>;
+    publishedAt?: InputMaybe<DateRangeInput>;
+    updatedAt?: InputMaybe<DateRangeInput>;
+    userIds?: InputMaybe<Array<InputMaybe<Scalars['ID']['input']>>>;
+    version?: InputMaybe<RegexExpressionInput>;
+};
+export type PluginsResult = {
+    __typename?: 'PluginsResult';
+    info: QueryInfo;
+    nodes: Array<Plugin>;
+};
+export type Product = {
+    __typename?: 'Product';
+    active: Scalars['Boolean']['output'];
+    adjustmentAmount?: Maybe<Scalars['Float']['output']>;
+    adjustmentType?: Maybe<Scalars['String']['output']>;
+    archived: Scalars['Boolean']['output'];
+    archivedAt?: Maybe<Scalars['DateTime']['output']>;
+    availableForBooking: Scalars['Boolean']['output'];
+    billingResponsibility: BillingResponsibility;
+    clientKeys: Array<Scalars['String']['output']>;
+    createdAt: Scalars['DateTime']['output'];
+    descriptionPrivate?: Maybe<Scalars['String']['output']>;
+    descriptionPublic?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    listPrice: Scalars['Float']['output'];
+    name?: Maybe<Scalars['String']['output']>;
+    notes?: Maybe<Scalars['String']['output']>;
+    requiresPaymentMethod: Scalars['Boolean']['output'];
+    sku: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+    wholesalePrice: Scalars['Float']['output'];
+};
+export type ProductsQueryInput = {
+    active?: InputMaybe<YesNoAnyInput>;
+    archived?: InputMaybe<YesNoAnyInput>;
+    archivedAt?: InputMaybe<DateRangeInput>;
+    createdAt?: InputMaybe<DateRangeInput>;
+    descriptionPrivate?: InputMaybe<RegexExpressionInput>;
+    descriptionPublic?: InputMaybe<RegexExpressionInput>;
+    name?: InputMaybe<RegexExpressionInput>;
+    sku?: InputMaybe<RegexExpressionInput>;
+    updatedAt?: InputMaybe<DateRangeInput>;
+};
+export type ProductsResult = {
+    __typename?: 'ProductsResult';
+    info: QueryInfo;
+    nodes: Array<Product>;
+};
+export type Query = {
+    __typename?: 'Query';
+    author?: Maybe<Author>;
+    authors: AuthorsResult;
+    board?: Maybe<Board>;
+    boardByKey?: Maybe<Board>;
+    boards: BoardsResult;
+    book?: Maybe<Book>;
+    books: BooksResult;
+    command?: Maybe<Command>;
+    commandGroup?: Maybe<CommandGroup>;
+    commandGroups: CommandGroupsResult;
+    commands: CommandsResult;
+    currentLogin?: Maybe<Auth>;
+    currentUser: User;
+    imageData: ImageDataResult;
+    integration?: Maybe<Integration>;
+    integrations: IntegrationsResult;
+    layout?: Maybe<Layout>;
+    layouts: LayoutsResult;
+    plugin?: Maybe<Plugin>;
+    plugins: PluginsResult;
+    product?: Maybe<Product>;
+    products: ProductsResult;
+    user?: Maybe<User>;
+    users: UsersResult;
+    zone?: Maybe<Zone>;
+    zones: ZonesResult;
+};
+export type QueryAuthorArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryAuthorsArgs = {
+    order?: InputMaybe<Array<OrderByInput>>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    perPage?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<AuthorsQueryInput>;
+};
+export type QueryBoardArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryBoardByKeyArgs = {
+    key: Scalars['ID']['input'];
+};
+export type QueryBoardsArgs = {
+    order?: InputMaybe<Array<OrderByInput>>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    perPage?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<BoardsQueryInput>;
+};
+export type QueryBookArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryBooksArgs = {
+    order?: InputMaybe<Array<OrderByInput>>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    perPage?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<BooksQueryInput>;
+};
+export type QueryCommandArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryCommandGroupArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryCommandGroupsArgs = {
+    order?: InputMaybe<Array<OrderByInput>>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    perPage?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<CommandGroupsQueryInput>;
+};
+export type QueryCommandsArgs = {
+    order?: InputMaybe<Array<OrderByInput>>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    perPage?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<CommandsQueryInput>;
+};
+export type QueryImageDataArgs = {
+    url: Scalars['String']['input'];
+};
+export type QueryIntegrationArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryIntegrationsArgs = {
+    order?: InputMaybe<Array<OrderByInput>>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    perPage?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<IntegrationsQueryInput>;
+};
+export type QueryLayoutArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryLayoutsArgs = {
+    order?: InputMaybe<Array<OrderByInput>>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    perPage?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<LayoutsQueryInput>;
+};
+export type QueryPluginArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryPluginsArgs = {
+    order?: InputMaybe<Array<OrderByInput>>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    perPage?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<PluginsQueryInput>;
+};
+export type QueryProductArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryProductsArgs = {
+    order?: InputMaybe<Array<OrderByInput>>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    perPage?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<ProductsQueryInput>;
+};
+export type QueryUserArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryUsersArgs = {
+    order?: InputMaybe<Array<OrderByInput>>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    perPage?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<UsersQueryInput>;
+};
+export type QueryZoneArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryZonesArgs = {
+    order?: InputMaybe<Array<OrderByInput>>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    perPage?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<ZonesQueryInput>;
+};
+export type QueryInfo = {
+    __typename?: 'QueryInfo';
+    at: Scalars['DateTime']['output'];
+    page: Scalars['Int']['output'];
+    perPage: Scalars['Int']['output'];
+    totalCount: Scalars['Int']['output'];
+};
+export type RegexExpressionInput = {
+    flags?: InputMaybe<RegexFlags>;
+    pattern: Scalars['String']['input'];
+};
+export declare enum RegexFlags {
+    I = "i",
+    Im = "im",
+    Is = "is",
+    Ism = "ism",
+    M = "m",
+    S = "s",
+    Sm = "sm"
+}
+export type RegisterResult = {
+    __typename?: 'RegisterResult';
+    error?: Maybe<Error>;
+};
+export type Subscription = {
+    __typename?: 'Subscription';
+    authorChange: AuthorChangeResult;
+    boardChange: BoardChangeResult;
+    bookChange: BookChangeResult;
+    commandChange: CommandChangeResult;
+    commandGroupChange: CommandGroupChangeResult;
+    integrationChange: IntegrationChangeResult;
+    layoutChange: LayoutChangeResult;
+    pluginChange: PluginChangeResult;
+    userChange: UserChangeResult;
+    userConfigChange: UserConfigChangeResult;
+    zoneChange: ZoneChangeResult;
+};
+export type UpdateAuthorInput = {
+    archived?: InputMaybe<Scalars['Boolean']['input']>;
+    email?: InputMaybe<Scalars['String']['input']>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    ssn?: InputMaybe<Scalars['String']['input']>;
+};
+export type UpdateAuthorResult = {
+    __typename?: 'UpdateAuthorResult';
+    author?: Maybe<Author>;
+    error?: Maybe<Error>;
+};
+export type UpdateBoardInput = {
+    archived?: InputMaybe<Scalars['Boolean']['input']>;
+    layout?: InputMaybe<Scalars['String']['input']>;
+    title?: InputMaybe<Scalars['String']['input']>;
+};
+export type UpdateBoardResult = {
+    __typename?: 'UpdateBoardResult';
+    board?: Maybe<Board>;
+    error?: Maybe<Error>;
+};
+export type UpdateBookInput = {
+    abstract?: InputMaybe<Scalars['String']['input']>;
+    archived?: InputMaybe<Scalars['Boolean']['input']>;
+    coverImageUrl?: InputMaybe<Scalars['String']['input']>;
+    publishedAt?: InputMaybe<Scalars['DateTime']['input']>;
+    title?: InputMaybe<Scalars['String']['input']>;
+};
+export type UpdateBookResult = {
+    __typename?: 'UpdateBookResult';
+    book?: Maybe<Book>;
+    error?: Maybe<Error>;
+};
+export type UpdateCommandGroupInput = {
+    archived?: InputMaybe<Scalars['Boolean']['input']>;
+    commandIds: Array<Scalars['String']['input']>;
+    title?: InputMaybe<Scalars['String']['input']>;
+};
+export type UpdateCommandGroupResult = {
+    __typename?: 'UpdateCommandGroupResult';
+    commandGroup?: Maybe<CommandGroup>;
+    error?: Maybe<Error>;
+};
+export type UpdateCommandInput = {
+    archived?: InputMaybe<Scalars['Boolean']['input']>;
+    component?: InputMaybe<Scalars['String']['input']>;
+    containerProps?: InputMaybe<Array<CommandPropInput>>;
+    plugin?: InputMaybe<Scalars['String']['input']>;
+    props?: InputMaybe<Array<CommandPropInput>>;
+    title?: InputMaybe<Scalars['String']['input']>;
+};
+export type UpdateCommandResult = {
+    __typename?: 'UpdateCommandResult';
+    command?: Maybe<Command>;
+    error?: Maybe<Error>;
+};
+export type UpdateIntegrationInput = {
+    archived?: InputMaybe<Scalars['Boolean']['input']>;
+    pluginConfig?: InputMaybe<Array<PluginConfigInput>>;
+    pluginVersion?: InputMaybe<Scalars['String']['input']>;
+    title?: InputMaybe<Scalars['String']['input']>;
+};
+export type UpdateIntegrationResult = {
+    __typename?: 'UpdateIntegrationResult';
+    error?: Maybe<Error>;
+    integration?: Maybe<Integration>;
+};
+export type UpdateLayoutInput = {
+    archived?: InputMaybe<Scalars['Boolean']['input']>;
+    content?: InputMaybe<Scalars['String']['input']>;
+    title?: InputMaybe<Scalars['String']['input']>;
+};
+export type UpdateLayoutResult = {
+    __typename?: 'UpdateLayoutResult';
+    error?: Maybe<Error>;
+    layout?: Maybe<Layout>;
+};
+export type UpdateProductInput = {
+    active?: InputMaybe<Scalars['Boolean']['input']>;
+    adjustmentAmount?: InputMaybe<Scalars['Float']['input']>;
+    adjustmentType?: InputMaybe<Scalars['String']['input']>;
+    archived?: InputMaybe<Scalars['Boolean']['input']>;
+    availableForBooking?: InputMaybe<Scalars['Boolean']['input']>;
+    billingResponsibility?: InputMaybe<BillingResponsibility>;
+    clientKeys?: InputMaybe<Array<Scalars['String']['input']>>;
+    descriptionPrivate?: InputMaybe<Scalars['String']['input']>;
+    descriptionPublic?: InputMaybe<Scalars['String']['input']>;
+    listPrice?: InputMaybe<Scalars['Float']['input']>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    notes?: InputMaybe<Scalars['String']['input']>;
+    requiresPaymentMethod?: InputMaybe<Scalars['Boolean']['input']>;
+    sku?: InputMaybe<Scalars['String']['input']>;
+    wholesalePrice?: InputMaybe<Scalars['Float']['input']>;
+};
+export type UpdateProductResult = {
+    __typename?: 'UpdateProductResult';
+    error?: Maybe<Error>;
+    product?: Maybe<Product>;
+};
+export type UpdateUserConfigInput = {
+    plugins: Array<UserConfigPluginInput>;
+};
+export type UpdateUserConfigResult = {
+    __typename?: 'UpdateUserConfigResult';
+    error?: Maybe<Error>;
+    userConfig?: Maybe<UserConfig>;
+};
+export type UpdateUserInput = {
+    archived?: InputMaybe<Scalars['Boolean']['input']>;
+    avatar?: InputMaybe<Scalars['String']['input']>;
+    email?: InputMaybe<Scalars['String']['input']>;
+    location?: InputMaybe<Scalars['String']['input']>;
+    name?: InputMaybe<Scalars['String']['input']>;
+};
+export type UpdateUserResult = {
+    __typename?: 'UpdateUserResult';
+    error?: Maybe<Error>;
+    user?: Maybe<User>;
+};
+export type UpdateZoneInput = {
+    archived?: InputMaybe<Scalars['Boolean']['input']>;
+    component?: InputMaybe<Scalars['String']['input']>;
+    containerProps?: InputMaybe<Array<ZonePropInput>>;
+    key?: InputMaybe<Scalars['String']['input']>;
+    plugin?: InputMaybe<Scalars['String']['input']>;
+    props?: InputMaybe<Array<ZonePropInput>>;
+};
+export type UpdateZoneResult = {
+    __typename?: 'UpdateZoneResult';
+    error?: Maybe<Error>;
+    zone?: Maybe<Zone>;
+};
+export type User = {
+    __typename?: 'User';
+    archived: Scalars['Boolean']['output'];
+    archivedAt?: Maybe<Scalars['DateTime']['output']>;
+    avatar?: Maybe<Scalars['String']['output']>;
+    boards: Array<Board>;
+    commandGroups: Array<CommandGroup>;
+    commands: Array<Command>;
+    createdAt: Scalars['DateTime']['output'];
+    email: Scalars['String']['output'];
+    id: Scalars['ID']['output'];
+    integrations: Array<Integration>;
+    location?: Maybe<Scalars['String']['output']>;
+    name: Scalars['String']['output'];
+    plugins: Array<Plugin>;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type UserChangeResult = {
+    __typename?: 'UserChangeResult';
+    action: ChangeAction;
+    id: Scalars['ID']['output'];
+    user?: Maybe<User>;
+};
+export type UserConfig = {
+    __typename?: 'UserConfig';
+    archived: Scalars['Boolean']['output'];
+    archivedAt?: Maybe<Scalars['DateTime']['output']>;
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    plugins: Array<UserConfigPlugin>;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type UserConfigChangeResult = {
+    __typename?: 'UserConfigChangeResult';
+    action: ChangeAction;
+    id: Scalars['ID']['output'];
+    userConfig?: Maybe<UserConfig>;
+};
+export type UserConfigPlugin = {
+    __typename?: 'UserConfigPlugin';
+    name: Scalars['String']['output'];
+    version?: Maybe<Scalars['String']['output']>;
+};
+export type UserConfigPluginInput = {
+    name: Scalars['String']['input'];
+    version?: InputMaybe<Scalars['String']['input']>;
+};
+export type UserConfigsResult = {
+    __typename?: 'UserConfigsResult';
+    info: QueryInfo;
+    nodes: Array<UserConfig>;
+};
+export type UsersQueryInput = {
+    archived?: InputMaybe<YesNoAnyInput>;
+    createdAt?: InputMaybe<DateRangeInput>;
+    email?: InputMaybe<RegexExpressionInput>;
+    location?: InputMaybe<RegexExpressionInput>;
+    name?: InputMaybe<RegexExpressionInput>;
+    updatedAt?: InputMaybe<DateRangeInput>;
+};
+export type UsersResult = {
+    __typename?: 'UsersResult';
+    info: QueryInfo;
+    nodes: Array<User>;
+};
+export declare enum YesNoAnyInput {
+    Any = "ANY",
+    No = "NO",
+    Yes = "YES"
+}
+export type Zone = {
+    __typename?: 'Zone';
+    archived: Scalars['Boolean']['output'];
+    archivedAt?: Maybe<Scalars['DateTime']['output']>;
+    board: Board;
+    component: Scalars['String']['output'];
+    containerProps: Array<ZoneProp>;
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    key: Scalars['String']['output'];
+    plugin: Scalars['String']['output'];
+    props: Array<ZoneProp>;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type ZoneChangeResult = {
+    __typename?: 'ZoneChangeResult';
+    action: ChangeAction;
+    id: Scalars['ID']['output'];
+    zone?: Maybe<Zone>;
+};
+export type ZoneProp = {
+    __typename?: 'ZoneProp';
+    key: Scalars['String']['output'];
+    value: Scalars['String']['output'];
+};
+export type ZonePropInput = {
+    key: Scalars['String']['input'];
+    value: Scalars['String']['input'];
+};
+export type ZonesQueryInput = {
+    archived?: InputMaybe<YesNoAnyInput>;
+    boardIds?: InputMaybe<Array<InputMaybe<Scalars['ID']['input']>>>;
+    createdAt?: InputMaybe<DateRangeInput>;
+    title?: InputMaybe<RegexExpressionInput>;
+    updatedAt?: InputMaybe<DateRangeInput>;
+};
+export type ZonesResult = {
+    __typename?: 'ZonesResult';
+    info: QueryInfo;
+    nodes: Array<Zone>;
+};
+export type UserDataQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type UserDataQuery = {
+    __typename?: 'Query';
+    currentUser: {
+        __typename?: 'User';
+        id: string;
+        name: string;
+        email: string;
+        location?: string | null;
+        avatar?: string | null;
+        boards: Array<{
+            __typename?: 'Board';
+            id: string;
+            title: string;
+            key: string;
+            layout?: string | null;
+            zones: Array<{
+                __typename?: 'Zone';
+                key: string;
+                plugin: string;
+                component: string;
+                props: Array<{
+                    __typename?: 'ZoneProp';
+                    key: string;
+                    value: string;
+                }>;
+                containerProps: Array<{
+                    __typename?: 'ZoneProp';
+                    key: string;
+                    value: string;
+                }>;
+            }>;
+        }>;
+        commandGroups: Array<{
+            __typename?: 'CommandGroup';
+            title: string;
+            key: string;
+            commands: Array<{
+                __typename?: 'Command';
+                title: string;
+                plugin: string;
+                component: string;
+                props: Array<{
+                    __typename?: 'CommandProp';
+                    key: string;
+                    value: string;
+                }>;
+            }>;
+        }>;
+    };
+};
+export type UserPluginsAndIntegrationsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type UserPluginsAndIntegrationsQuery = {
+    __typename?: 'Query';
+    currentUser: {
+        __typename?: 'User';
+        plugins: Array<{
+            __typename?: 'Plugin';
+            name: string;
+            code: string;
+        }>;
+        integrations: Array<{
+            __typename?: 'Integration';
+            key: string;
+            pluginName: string;
+            pluginVersion?: string | null;
+            pluginConfig: Array<{
+                __typename?: 'PluginConfig';
+                key: string;
+                value: string;
+            }>;
+        }>;
+    };
+};
+export type UserChangeSubscriptionVariables = Exact<{
+    [key: string]: never;
+}>;
+export type UserChangeSubscription = {
+    __typename?: 'Subscription';
+    userChange: {
+        __typename?: 'UserChangeResult';
+        user?: {
+            __typename?: 'User';
+            id: string;
+        } | null;
+    };
+};
+export declare const UserDataDocument: DocumentNode<UserDataQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare const UserPluginsAndIntegrationsDocument: DocumentNode<UserPluginsAndIntegrationsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare const UserChangeDocument: DocumentNode<UserChangeSubscription, Exact<{
+    [key: string]: never;
+}>>;