@platecms/delta-client 0.1.0

package/src/__generated__/graphql.d.ts

@@ -0,0 +1,1821 @@
+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;
+};
+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;
+    };
+    CAST: {
+        input: any;
+        output: any;
+    };
+    ContentValueType: {
+        input: any;
+        output: any;
+    };
+    DateTime: {
+        input: any;
+        output: any;
+    };
+    PRN: {
+        input: any;
+        output: any;
+    };
+    PrimitiveValue: {
+        input: any;
+        output: any;
+    };
+};
+export type AllowedValuesContentValidationRuleSettings = {
+    __typename?: 'AllowedValuesContentValidationRuleSettings';
+    allowedValues: Array<Scalars['ContentValueType']['output']>;
+};
+export type AllowedValuesContentValidationRuleSettingsInput = {
+    allowedValues: Array<Scalars['ContentValueType']['input']>;
+};
+export type ApiToken = {
+    __typename?: 'ApiToken';
+    channel: Channel;
+    createdAt: Scalars['DateTime']['output'];
+    name: Scalars['String']['output'];
+    prn: Scalars['PRN']['output'];
+    stage: Stage;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type Asset = {
+    __typename?: 'Asset';
+    createdAt: Scalars['DateTime']['output'];
+    fileName: Scalars['String']['output'];
+    fileSize: Scalars['Int']['output'];
+    mimeType: Scalars['String']['output'];
+    prn: Scalars['PRN']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+    url?: Maybe<Scalars['String']['output']>;
+};
+export type Blueprint = {
+    __typename?: 'Blueprint';
+    channel: Channel;
+    createdAt: Scalars['DateTime']['output'];
+    definedBy: ExperienceComponent;
+    isFixed: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+    organization?: Maybe<Organization>;
+    preview?: Maybe<Asset>;
+    prn: Scalars['PRN']['output'];
+    stage: Stage;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type BlueprintEdge = {
+    __typename?: 'BlueprintEdge';
+    cursor: Scalars['String']['output'];
+    node: Blueprint;
+};
+export type BlueprintsConnection = {
+    __typename?: 'BlueprintsConnection';
+    edges: Array<BlueprintEdge>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type BlueprintsFilterInput = {
+    _not?: InputMaybe<Array<BlueprintsFilterInput>>;
+    createdAt?: InputMaybe<Array<DateFilter>>;
+    isFixed?: InputMaybe<Array<BooleanFilter>>;
+    name?: InputMaybe<Array<StringFilter>>;
+    prn?: InputMaybe<Array<PrnFilter>>;
+    updatedAt?: InputMaybe<Array<DateFilter>>;
+};
+export type BooleanFilter = {
+    _eq?: InputMaybe<Scalars['Boolean']['input']>;
+    _is_not_null?: InputMaybe<Scalars['Boolean']['input']>;
+    _is_null?: InputMaybe<Scalars['Boolean']['input']>;
+    _neq?: InputMaybe<Scalars['Boolean']['input']>;
+};
+export type BuildingBlock = {
+    __typename?: 'BuildingBlock';
+    buildingBlockFields: Array<BuildingBlockField>;
+    createdAt: Scalars['DateTime']['output'];
+    experienceComponents: Array<ExperienceComponent>;
+    gridDefinition?: Maybe<GridDefinition>;
+    next?: Maybe<BuildingBlock>;
+    organization?: Maybe<Organization>;
+    preview?: Maybe<Asset>;
+    previous?: Maybe<BuildingBlock>;
+    prn: Scalars['PRN']['output'];
+    slug: Scalars['String']['output'];
+    theme: Theme;
+    title: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type BuildingBlockBuildingBlockFieldsArgs = {
+    where?: InputMaybe<Array<BuildingBlockFieldsFilterInput>>;
+};
+export type BuildingBlockExperienceComponentsArgs = {
+    where?: InputMaybe<Array<ExperienceComponentsFilterInput>>;
+};
+export type BuildingBlockField = {
+    __typename?: 'BuildingBlockField';
+    buildingBlock: BuildingBlock;
+    createdAt: Scalars['DateTime']['output'];
+    fieldTypes: Array<ContentValueTypeNames>;
+    maxCount?: Maybe<Scalars['Int']['output']>;
+    minCount: Scalars['Int']['output'];
+    next?: Maybe<BuildingBlockField>;
+    organization?: Maybe<Organization>;
+    previous?: Maybe<BuildingBlockField>;
+    prn: Scalars['PRN']['output'];
+    slug: Scalars['String']['output'];
+    title: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type BuildingBlockFieldEdge = {
+    __typename?: 'BuildingBlockFieldEdge';
+    cursor: Scalars['String']['output'];
+    node: BuildingBlockField;
+};
+export type BuildingBlockFieldFulfillment = {
+    __typename?: 'BuildingBlockFieldFulfillment';
+    blueprintedBy?: Maybe<BuildingBlockFieldFulfillment>;
+    blueprintedInstances?: Maybe<Array<BuildingBlockFieldFulfillment>>;
+    buildingBlockField: BuildingBlockField;
+    contentValue: ContentValue;
+    createdAt: Scalars['DateTime']['output'];
+    experienceComponent: ExperienceComponent;
+    next?: Maybe<BuildingBlockFieldFulfillment>;
+    organization?: Maybe<Organization>;
+    previous?: Maybe<BuildingBlockFieldFulfillment>;
+    prn: Scalars['PRN']['output'];
+    stage: Stage;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type BuildingBlockFieldFulfillmentBlueprintedInstancesArgs = {
+    where?: InputMaybe<Array<BuildingBlockFieldFulfillmentsFilterInput>>;
+};
+export type BuildingBlockFieldFulfillmentContentValueArgs = {
+    where?: InputMaybe<Array<ContentValuesFilterInput>>;
+};
+export type BuildingBlockFieldFulfillmentEdge = {
+    __typename?: 'BuildingBlockFieldFulfillmentEdge';
+    cursor: Scalars['String']['output'];
+    node: BuildingBlockFieldFulfillment;
+};
+export type BuildingBlockFieldFulfillmentsConnection = {
+    __typename?: 'BuildingBlockFieldFulfillmentsConnection';
+    edges: Array<BuildingBlockFieldFulfillmentEdge>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type BuildingBlockFieldFulfillmentsFilterInput = {
+    _not?: InputMaybe<Array<BuildingBlockFieldFulfillmentsFilterInput>>;
+    createdAt?: InputMaybe<Array<DateFilter>>;
+    prn?: InputMaybe<Array<PrnFilter>>;
+    updatedAt?: InputMaybe<Array<DateFilter>>;
+};
+export type BuildingBlockFieldsConnection = {
+    __typename?: 'BuildingBlockFieldsConnection';
+    edges: Array<BuildingBlockFieldEdge>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type BuildingBlockFieldsFilterInput = {
+    _not?: InputMaybe<Array<BuildingBlockFieldsFilterInput>>;
+    createdAt?: InputMaybe<Array<DateFilter>>;
+    maxCount?: InputMaybe<Array<IntFilter>>;
+    minCount?: InputMaybe<Array<IntFilter>>;
+    prn?: InputMaybe<Array<PrnFilter>>;
+    slug?: InputMaybe<Array<StringFilter>>;
+    title?: InputMaybe<Array<StringFilter>>;
+    updatedAt?: InputMaybe<Array<DateFilter>>;
+};
+export type BuildingBlocksFilterInput = {
+    _not?: InputMaybe<Array<BuildingBlocksFilterInput>>;
+    createdAt?: InputMaybe<Array<DateFilter>>;
+    prn?: InputMaybe<Array<PrnFilter>>;
+    slug?: InputMaybe<Array<StringFilter>>;
+    title?: InputMaybe<Array<StringFilter>>;
+    updatedAt?: InputMaybe<Array<DateFilter>>;
+};
+export type Channel = {
+    __typename?: 'Channel';
+    apiTokens: Array<ApiToken>;
+    blueprints: Array<Blueprint>;
+    createdAt: Scalars['DateTime']['output'];
+    defaultBlueprint?: Maybe<Blueprint>;
+    domain: Scalars['String']['output'];
+    name: Scalars['String']['output'];
+    organization?: Maybe<Organization>;
+    pathParts: Array<PathPart>;
+    prn: Scalars['PRN']['output'];
+    rootPathPart: PathPart;
+    slug: Scalars['String']['output'];
+    stage: Stage;
+    theme: Theme;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type ChannelPathPartsArgs = {
+    where?: InputMaybe<Array<PathPartsFilterInput>>;
+};
+export type ChannelEdge = {
+    __typename?: 'ChannelEdge';
+    cursor: Scalars['String']['output'];
+    node: Channel;
+};
+export type ChannelsConnection = {
+    __typename?: 'ChannelsConnection';
+    edges: Array<ChannelEdge>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type ChannelsFilterInput = {
+    _not?: InputMaybe<Array<ChannelsFilterInput>>;
+    createdAt?: InputMaybe<Array<DateFilter>>;
+    domain?: InputMaybe<Array<StringFilter>>;
+    name?: InputMaybe<Array<StringFilter>>;
+    prn?: InputMaybe<Array<PrnFilter>>;
+    slug?: InputMaybe<Array<StringFilter>>;
+    updatedAt?: InputMaybe<Array<DateFilter>>;
+};
+export type ConnectContentValueInput = {
+    contentField: Scalars['PRN']['input'];
+    contentValue: Scalars['PRN']['input'];
+};
+export type ContentExperience = {
+    __typename?: 'ContentExperience';
+    createdAt: Scalars['DateTime']['output'];
+    experienceComponent: ExperienceComponent;
+    organization?: Maybe<Organization>;
+    pathPart: PathPart;
+    preview?: Maybe<Asset>;
+    prn: Scalars['PRN']['output'];
+    slug: Scalars['String']['output'];
+    stage: Stage;
+    title: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type ContentExperienceEdge = {
+    __typename?: 'ContentExperienceEdge';
+    cursor: Scalars['String']['output'];
+    node: ContentExperience;
+};
+export type ContentExperiencesConnection = {
+    __typename?: 'ContentExperiencesConnection';
+    edges: Array<ContentExperienceEdge>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type ContentExperiencesFilterInput = {
+    _not?: InputMaybe<Array<ContentExperiencesFilterInput>>;
+    createdAt?: InputMaybe<Array<DateFilter>>;
+    prn?: InputMaybe<Array<PrnFilter>>;
+    slug?: InputMaybe<Array<StringFilter>>;
+    title?: InputMaybe<Array<StringFilter>>;
+    updatedAt?: InputMaybe<Array<DateFilter>>;
+};
+export type ContentField = {
+    __typename?: 'ContentField';
+    contentType: ContentType;
+    contentValidationRules: Array<ContentValidationRule>;
+    contentValues: Array<ContentValue>;
+    createdAt: Scalars['DateTime']['output'];
+    name: Scalars['String']['output'];
+    next?: Maybe<ContentField>;
+    organization?: Maybe<Organization>;
+    previous?: Maybe<ContentField>;
+    prn: Scalars['PRN']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type ContentFieldContentValidationRulesArgs = {
+    where?: InputMaybe<Array<ContentValidationRulesFilterInput>>;
+};
+export type ContentFieldContentValuesArgs = {
+    where?: InputMaybe<Array<ContentValuesFilterInput>>;
+};
+export type ContentFieldEdge = {
+    __typename?: 'ContentFieldEdge';
+    cursor: Scalars['String']['output'];
+    node: ContentField;
+};
+export type ContentFieldsConnection = {
+    __typename?: 'ContentFieldsConnection';
+    edges: Array<ContentFieldEdge>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type ContentFieldsFilterInput = {
+    _not?: InputMaybe<Array<ContentFieldsFilterInput>>;
+    createdAt?: InputMaybe<Array<DateFilter>>;
+    name?: InputMaybe<Array<StringFilter>>;
+    prn?: InputMaybe<Array<PrnFilter>>;
+    updatedAt?: InputMaybe<Array<DateFilter>>;
+};
+export type ContentItem = {
+    __typename?: 'ContentItem';
+    contentType: ContentType;
+    contentValues: Array<ContentValue>;
+    createdAt: Scalars['DateTime']['output'];
+    displayImage?: Maybe<Asset>;
+    displayName: Scalars['String']['output'];
+    isDraft: Scalars['Boolean']['output'];
+    organization?: Maybe<Organization>;
+    prn: Scalars['PRN']['output'];
+    relatingContentValues: Array<ContentValue>;
+    stage: Stage;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type ContentItemContentValuesArgs = {
+    where?: InputMaybe<Array<ContentValuesFilterInput>>;
+};
+export type ContentItemRelatingContentValuesArgs = {
+    where?: InputMaybe<Array<ContentValuesFilterInput>>;
+};
+export type ContentItemEdge = {
+    __typename?: 'ContentItemEdge';
+    cursor: Scalars['String']['output'];
+    node: ContentItem;
+};
+export type ContentItemsConnection = {
+    __typename?: 'ContentItemsConnection';
+    edges: Array<ContentItemEdge>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type ContentItemsFilterInput = {
+    _not?: InputMaybe<Array<ContentItemsFilterInput>>;
+    createdAt?: InputMaybe<Array<DateFilter>>;
+    isDraft?: InputMaybe<Array<BooleanFilter>>;
+    prn?: InputMaybe<Array<PrnFilter>>;
+    updatedAt?: InputMaybe<Array<DateFilter>>;
+};
+export type ContentType = {
+    __typename?: 'ContentType';
+    contentFields: Array<ContentField>;
+    contentItems: Array<ContentItem>;
+    createdAt: Scalars['DateTime']['output'];
+    displayImageField?: Maybe<ContentField>;
+    displayNameTemplate: Scalars['String']['output'];
+    name: Scalars['String']['output'];
+    organization?: Maybe<Organization>;
+    prn: Scalars['PRN']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type ContentTypeContentFieldsArgs = {
+    where?: InputMaybe<Array<ContentFieldsFilterInput>>;
+};
+export type ContentTypeContentItemsArgs = {
+    where?: InputMaybe<Array<ContentItemsFilterInput>>;
+};
+export type ContentTypeEdge = {
+    __typename?: 'ContentTypeEdge';
+    cursor: Scalars['String']['output'];
+    node: ContentType;
+};
+export type ContentTypesConnection = {
+    __typename?: 'ContentTypesConnection';
+    edges: Array<ContentTypeEdge>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type ContentTypesFilterInput = {
+    _not?: InputMaybe<Array<ContentTypesFilterInput>>;
+    createdAt?: InputMaybe<Array<DateFilter>>;
+    displayNameTemplate?: InputMaybe<Array<StringFilter>>;
+    name?: InputMaybe<Array<StringFilter>>;
+    prn?: InputMaybe<Array<PrnFilter>>;
+    updatedAt?: InputMaybe<Array<DateFilter>>;
+};
+export type ContentValidationRule = {
+    __typename?: 'ContentValidationRule';
+    contentField: ContentField;
+    createdAt: Scalars['DateTime']['output'];
+    organization?: Maybe<Organization>;
+    prn: Scalars['PRN']['output'];
+    ruleType: RuleType;
+    settings: ExistingContentValidationRulesSettings;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type ContentValidationRulesFilterInput = {
+    _not?: InputMaybe<Array<ContentValidationRulesFilterInput>>;
+    createdAt?: InputMaybe<Array<DateFilter>>;
+    prn?: InputMaybe<Array<PrnFilter>>;
+    updatedAt?: InputMaybe<Array<DateFilter>>;
+};
+export type ContentValue = {
+    __typename?: 'ContentValue';
+    buildingBlockFieldFulfillments: Array<BuildingBlockFieldFulfillment>;
+    contentField?: Maybe<ContentField>;
+    contentItem?: Maybe<ContentItem>;
+    createdAt: Scalars['DateTime']['output'];
+    interpolatedSmartText?: Maybe<Scalars['CAST']['output']>;
+    linkedGridPlacement?: Maybe<GridPlacement>;
+    linkedPathPart?: Maybe<PathPart>;
+    next?: Maybe<ContentValue>;
+    organization?: Maybe<Organization>;
+    plainText?: Maybe<Scalars['String']['output']>;
+    previous?: Maybe<ContentValue>;
+    primitiveValue?: Maybe<Scalars['PrimitiveValue']['output']>;
+    prn: Scalars['PRN']['output'];
+    referencedBy: Array<ContentValue>;
+    referencedContentValues: Array<ContentValue>;
+    relatedAsset?: Maybe<Asset>;
+    relatedContentItem?: Maybe<ContentItem>;
+    smartText?: Maybe<Scalars['CAST']['output']>;
+    stage: Stage;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type ContentValueBuildingBlockFieldFulfillmentsArgs = {
+    where?: InputMaybe<Array<BuildingBlockFieldFulfillmentsFilterInput>>;
+};
+export type ContentValueEdge = {
+    __typename?: 'ContentValueEdge';
+    cursor: Scalars['String']['output'];
+    node: ContentValue;
+};
+export declare enum ContentValueTypeNames {
+    Asset = "ASSET",
+    Boolean = "BOOLEAN",
+    ContentItem = "CONTENT_ITEM",
+    Date = "DATE",
+    GridPlacement = "GRID_PLACEMENT",
+    Number = "NUMBER",
+    PathPart = "PATH_PART",
+    SmartText = "SMART_TEXT",
+    String = "STRING"
+}
+export type ContentValuesConnection = {
+    __typename?: 'ContentValuesConnection';
+    edges: Array<ContentValueEdge>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type ContentValuesFilterInput = {
+    _not?: InputMaybe<Array<ContentValuesFilterInput>>;
+    createdAt?: InputMaybe<Array<DateFilter>>;
+    plainText?: InputMaybe<Array<StringFilter>>;
+    primitiveValue?: InputMaybe<Array<StringFilter>>;
+    prn?: InputMaybe<Array<PrnFilter>>;
+    updatedAt?: InputMaybe<Array<DateFilter>>;
+};
+export type CopyBlueprintInput = {
+    name: Scalars['String']['input'];
+    preview?: InputMaybe<Scalars['PRN']['input']>;
+    prn: Scalars['PRN']['input'];
+};
+export type CountContentValidationRuleSettings = {
+    __typename?: 'CountContentValidationRuleSettings';
+    max: Scalars['Int']['output'];
+    min: Scalars['Int']['output'];
+};
+export type CountContentValidationRuleSettingsInput = {
+    max: Scalars['Int']['input'];
+    min: Scalars['Int']['input'];
+};
+export type CreateAllowedValuesContentValidationRuleInput = {
+    contentField: Scalars['PRN']['input'];
+    settings: AllowedValuesContentValidationRuleSettingsInput;
+};
+export type CreateApiTokenInput = {
+    channel: Scalars['PRN']['input'];
+    name: Scalars['String']['input'];
+};
+export type CreateApiTokenResponse = {
+    __typename?: 'CreateApiTokenResponse';
+    channel: Channel;
+    createdAt: Scalars['DateTime']['output'];
+    name: Scalars['String']['output'];
+    prn: Scalars['PRN']['output'];
+    stage: Stage;
+    token: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type CreateBlueprintFromContentExperienceInput = {
+    contentExperience: Scalars['PRN']['input'];
+    isFixed: Scalars['Boolean']['input'];
+    name: Scalars['String']['input'];
+    preview?: InputMaybe<Scalars['PRN']['input']>;
+};
+export type CreateBlueprintInput = {
+    channel: Scalars['PRN']['input'];
+    initialRowCount?: Scalars['Int']['input'];
+    isFixed: Scalars['Boolean']['input'];
+    name: Scalars['String']['input'];
+    preview?: InputMaybe<Scalars['PRN']['input']>;
+};
+export type CreateBuildingBlockFieldForBuildingBlockInput = {
+    fieldTypes: Array<ContentValueTypeNames>;
+    maxCount?: InputMaybe<Scalars['Int']['input']>;
+    minCount: Scalars['Int']['input'];
+    next?: InputMaybe<Scalars['PRN']['input']>;
+    slug: Scalars['String']['input'];
+    title: Scalars['String']['input'];
+};
+export type CreateBuildingBlockFieldFulfillmentForExperienceComponentInput = {
+    buildingBlockField: Scalars['PRN']['input'];
+    contentValue: Scalars['PRN']['input'];
+    next?: InputMaybe<Scalars['PRN']['input']>;
+};
+export type CreateBuildingBlockFieldFulfillmentInput = {
+    buildingBlockField: Scalars['PRN']['input'];
+    contentValue: Scalars['PRN']['input'];
+    experienceComponent: Scalars['PRN']['input'];
+    next?: InputMaybe<Scalars['PRN']['input']>;
+};
+export type CreateBuildingBlockFieldInput = {
+    buildingBlock: Scalars['PRN']['input'];
+    fieldTypes: Array<ContentValueTypeNames>;
+    maxCount?: InputMaybe<Scalars['Int']['input']>;
+    minCount: Scalars['Int']['input'];
+    next?: InputMaybe<Scalars['PRN']['input']>;
+    slug: Scalars['String']['input'];
+    title: Scalars['String']['input'];
+};
+export type CreateBuildingBlockForThemeInput = {
+    buildingBlockFields: Array<CreateBuildingBlockFieldForBuildingBlockInput>;
+    gridDefinition?: InputMaybe<CreateGridDefinitionInput>;
+    next?: InputMaybe<Scalars['PRN']['input']>;
+    preview?: InputMaybe<Scalars['PRN']['input']>;
+    slug: Scalars['String']['input'];
+    title: Scalars['String']['input'];
+};
+export type CreateBuildingBlockInput = {
+    buildingBlockFields: Array<CreateBuildingBlockFieldForBuildingBlockInput>;
+    gridDefinition?: InputMaybe<CreateGridDefinitionInput>;
+    next?: InputMaybe<Scalars['PRN']['input']>;
+    preview?: InputMaybe<Scalars['PRN']['input']>;
+    slug: Scalars['String']['input'];
+    theme: Scalars['PRN']['input'];
+    title: Scalars['String']['input'];
+};
+export type CreateChannelInput = {
+    domain: Scalars['String']['input'];
+    name: Scalars['String']['input'];
+    slug: Scalars['String']['input'];
+    theme: Scalars['PRN']['input'];
+};
+export type CreateContentExperienceWithExistingPathPartInput = {
+    fromBlueprint?: InputMaybe<Scalars['PRN']['input']>;
+    initialRowCount?: InputMaybe<Scalars['Int']['input']>;
+    pathPart: Scalars['PRN']['input'];
+    preview?: InputMaybe<Scalars['PRN']['input']>;
+    slug: Scalars['String']['input'];
+    title: Scalars['String']['input'];
+};
+export type CreateContentExperienceWithNewPathPartInput = {
+    createPathPartFromParent?: InputMaybe<CreatePathPartFromParentInput>;
+    createPathPartFromPath?: InputMaybe<CreatePathPartFromPathInput>;
+    fromBlueprint?: InputMaybe<Scalars['PRN']['input']>;
+    initialRowCount?: InputMaybe<Scalars['Int']['input']>;
+    preview?: InputMaybe<Scalars['PRN']['input']>;
+    slug: Scalars['String']['input'];
+    title: Scalars['String']['input'];
+};
+export type CreateContentFieldForContentTypeInput = {
+    name: Scalars['String']['input'];
+    next?: InputMaybe<Scalars['PRN']['input']>;
+};
+export type CreateContentFieldInput = {
+    contentType: Scalars['PRN']['input'];
+    name: Scalars['String']['input'];
+    next?: InputMaybe<Scalars['PRN']['input']>;
+};
+export type CreateContentItemInput = {
+    contentType: Scalars['PRN']['input'];
+    contentValuesToConnect?: InputMaybe<Array<ConnectContentValueInput>>;
+    contentValuesToCreate?: InputMaybe<Array<CreateContentValueForContentItemInput>>;
+    isDraft: Scalars['Boolean']['input'];
+};
+export type CreateContentTypeInput = {
+    contentFields?: Array<CreateContentFieldForContentTypeInput>;
+    displayImageField?: InputMaybe<Scalars['PRN']['input']>;
+    displayNameTemplate: Scalars['String']['input'];
+    name: Scalars['String']['input'];
+};
+export type CreateContentValueForContentItemInput = {
+    contentField: Scalars['PRN']['input'];
+    linkedGridPlacement?: InputMaybe<Scalars['PRN']['input']>;
+    linkedPathPart?: InputMaybe<Scalars['PRN']['input']>;
+    next?: InputMaybe<Scalars['PRN']['input']>;
+    primitiveValue?: InputMaybe<Scalars['PrimitiveValue']['input']>;
+    relatedAsset?: InputMaybe<Scalars['PRN']['input']>;
+    relatedContentItem?: InputMaybe<Scalars['PRN']['input']>;
+    smartText?: InputMaybe<Scalars['CAST']['input']>;
+};
+export type CreateContentValueInput = {
+    contentField?: InputMaybe<Scalars['PRN']['input']>;
+    contentItem?: InputMaybe<Scalars['PRN']['input']>;
+    linkedGridPlacement?: InputMaybe<Scalars['PRN']['input']>;
+    linkedPathPart?: InputMaybe<Scalars['PRN']['input']>;
+    next?: InputMaybe<Scalars['PRN']['input']>;
+    primitiveValue?: InputMaybe<Scalars['PrimitiveValue']['input']>;
+    relatedAsset?: InputMaybe<Scalars['PRN']['input']>;
+    relatedContentItem?: InputMaybe<Scalars['PRN']['input']>;
+    smartText?: InputMaybe<Scalars['CAST']['input']>;
+};
+export type CreateCountContentValidationRuleInput = {
+    contentField: Scalars['PRN']['input'];
+    settings: CountContentValidationRuleSettingsInput;
+};
+export type CreateDateBetweenContentValidationRuleInput = {
+    contentField: Scalars['PRN']['input'];
+    settings: DateBetweenContentValidationRuleSettingsInput;
+};
+export type CreateDecimalCountContentValidationRuleInput = {
+    contentField: Scalars['PRN']['input'];
+    settings: DecimalCountContentValidationRuleSettingsInput;
+};
+export type CreateExperienceComponentInput = {
+    buildingBlock: Scalars['PRN']['input'];
+    buildingBlockFieldFulfillments: Array<CreateBuildingBlockFieldFulfillmentForExperienceComponentInput>;
+    grid?: InputMaybe<CreateGridInput>;
+    gridPlacement?: InputMaybe<CreateGridPlacementInput>;
+    isDraft: Scalars['Boolean']['input'];
+    preview?: InputMaybe<Scalars['PRN']['input']>;
+};
+export type CreateGlobalExperienceComponentInput = {
+    buildingBlock: Scalars['PRN']['input'];
+    buildingBlockFieldFulfillments: Array<CreateBuildingBlockFieldFulfillmentForExperienceComponentInput>;
+    grid?: InputMaybe<CreateGridInput>;
+    gridPlacement?: InputMaybe<CreateGridPlacementInput>;
+    isDraft: Scalars['Boolean']['input'];
+    name: Scalars['String']['input'];
+    preview?: InputMaybe<Scalars['PRN']['input']>;
+};
+export type CreateGridDefinitionInput = {
+    buildingBlock?: InputMaybe<Scalars['PRN']['input']>;
+    maxRows: Scalars['Int']['input'];
+};
+export type CreateGridInput = {
+    experienceComponent?: InputMaybe<Scalars['PRN']['input']>;
+    gridDefinition: Scalars['PRN']['input'];
+    rows: Scalars['Int']['input'];
+};
+export type CreateGridPlacementInput = {
+    experienceComponent?: InputMaybe<Scalars['PRN']['input']>;
+    grid: Scalars['PRN']['input'];
+    row: Scalars['Int']['input'];
+};
+export type CreateInvitationInput = {
+    role: Scalars['PRN']['input'];
+    userEmail: Scalars['String']['input'];
+};
+export type CreateNumberBetweenContentValidationRuleInput = {
+    contentField: Scalars['PRN']['input'];
+    settings: NumberBetweenContentValidationRuleSettingsInput;
+};
+export type CreateOrganizationInput = {
+    logoUrl?: InputMaybe<Scalars['String']['input']>;
+    name: Scalars['String']['input'];
+    slug: Scalars['String']['input'];
+};
+export type CreatePathPartFromParentInput = {
+    parent: Scalars['String']['input'];
+    slug: Scalars['String']['input'];
+};
+export type CreatePathPartFromPathInput = {
+    channel: Scalars['PRN']['input'];
+    path: Scalars['String']['input'];
+};
+export type CreateRelatableContentTypesContentValidationRuleInput = {
+    contentField: Scalars['PRN']['input'];
+    settings: RelatableContentTypesContentValidationRuleSettingsInput;
+};
+export type CreateStringFormatContentValidationRuleInput = {
+    contentField: Scalars['PRN']['input'];
+    settings: StringFormatContentValidationRuleSettingsInput;
+};
+export type CreateThemeInput = {
+    buildingBlocks?: InputMaybe<Array<CreateBuildingBlockForThemeInput>>;
+    name: Scalars['String']['input'];
+    repositoryUrl: Scalars['String']['input'];
+};
+export type CreateValueTypeContentValidationRuleInput = {
+    contentField: Scalars['PRN']['input'];
+    settings: ValueTypeContentValidationRuleSettingsInput;
+};
+export type DateBetweenContentValidationRuleSettings = {
+    __typename?: 'DateBetweenContentValidationRuleSettings';
+    max: Scalars['String']['output'];
+    min: Scalars['String']['output'];
+};
+export type DateBetweenContentValidationRuleSettingsInput = {
+    max: Scalars['String']['input'];
+    min: Scalars['String']['input'];
+};
+export type DateFilter = {
+    _eq?: InputMaybe<Scalars['DateTime']['input']>;
+    _gt?: InputMaybe<Scalars['DateTime']['input']>;
+    _gte?: InputMaybe<Scalars['DateTime']['input']>;
+    _in?: InputMaybe<Array<Scalars['DateTime']['input']>>;
+    _is_not_null?: InputMaybe<Scalars['Boolean']['input']>;
+    _is_null?: InputMaybe<Scalars['Boolean']['input']>;
+    _lt?: InputMaybe<Scalars['DateTime']['input']>;
+    _lte?: InputMaybe<Scalars['DateTime']['input']>;
+    _neq?: InputMaybe<Scalars['DateTime']['input']>;
+    _nin?: InputMaybe<Array<Scalars['DateTime']['input']>>;
+};
+export type DecimalCountContentValidationRuleSettings = {
+    __typename?: 'DecimalCountContentValidationRuleSettings';
+    max: Scalars['Int']['output'];
+};
+export type DecimalCountContentValidationRuleSettingsInput = {
+    max: Scalars['Int']['input'];
+};
+export declare enum DefaultRoleName {
+    Admin = "ADMIN",
+    ContentEditor = "CONTENT_EDITOR"
+}
+export type ExistingContentValidationRulesSettings = AllowedValuesContentValidationRuleSettings | CountContentValidationRuleSettings | DateBetweenContentValidationRuleSettings | DecimalCountContentValidationRuleSettings | NumberBetweenContentValidationRuleSettings | RelatableContentTypesContentValidationRuleSettings | StringFormatContentValidationRuleSettings | ValueTypeContentValidationRuleSettings;
+export type ExperienceComponent = {
+    __typename?: 'ExperienceComponent';
+    blueprint?: Maybe<Blueprint>;
+    blueprintedBy?: Maybe<ExperienceComponent>;
+    blueprintedInstances?: Maybe<Array<ExperienceComponent>>;
+    buildingBlock: BuildingBlock;
+    buildingBlockFieldFulfillments: Array<BuildingBlockFieldFulfillment>;
+    contentExperience?: Maybe<ContentExperience>;
+    createdAt: Scalars['DateTime']['output'];
+    grid?: Maybe<Grid>;
+    gridPlacements: Array<GridPlacement>;
+    isDraft: Scalars['Boolean']['output'];
+    isGlobal: Scalars['Boolean']['output'];
+    name?: Maybe<Scalars['String']['output']>;
+    organization?: Maybe<Organization>;
+    preview?: Maybe<Asset>;
+    prn: Scalars['PRN']['output'];
+    stage: Stage;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type ExperienceComponentBlueprintedInstancesArgs = {
+    where?: InputMaybe<Array<ExperienceComponentsFilterInput>>;
+};
+export type ExperienceComponentBuildingBlockFieldFulfillmentsArgs = {
+    where?: InputMaybe<Array<BuildingBlockFieldFulfillmentsFilterInput>>;
+};
+export type ExperienceComponentGridPlacementsArgs = {
+    where?: InputMaybe<Array<GridPlacementsFilterInput>>;
+};
+export type ExperienceComponentEdge = {
+    __typename?: 'ExperienceComponentEdge';
+    cursor: Scalars['String']['output'];
+    node: ExperienceComponent;
+};
+export type ExperienceComponentsConnection = {
+    __typename?: 'ExperienceComponentsConnection';
+    edges: Array<ExperienceComponentEdge>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type ExperienceComponentsFilterInput = {
+    _not?: InputMaybe<Array<ExperienceComponentsFilterInput>>;
+    createdAt?: InputMaybe<Array<DateFilter>>;
+    isDraft?: InputMaybe<Array<BooleanFilter>>;
+    isGlobal?: InputMaybe<Array<BooleanFilter>>;
+    name?: InputMaybe<Array<StringFilter>>;
+    prn?: InputMaybe<Array<PrnFilter>>;
+    updatedAt?: InputMaybe<Array<DateFilter>>;
+};
+export type FindPathPartByPathInput = {
+    channel: Scalars['PRN']['input'];
+    path: Scalars['String']['input'];
+};
+export type GenerateAssetUploadUrlInput = {
+    fileName: Scalars['String']['input'];
+    fileSize: Scalars['Int']['input'];
+    mimeType?: Scalars['String']['input'];
+};
+export type GeneratedUploadUrl = {
+    __typename?: 'GeneratedUploadUrl';
+    prn: Scalars['PRN']['output'];
+    url: Scalars['String']['output'];
+};
+export type Grid = {
+    __typename?: 'Grid';
+    blueprintedBy?: Maybe<Grid>;
+    blueprintedInstances?: Maybe<Grid>;
+    createdAt: Scalars['DateTime']['output'];
+    experienceComponent: ExperienceComponent;
+    gridDefinition: GridDefinition;
+    gridPlacements: Array<GridPlacement>;
+    organization?: Maybe<Organization>;
+    prn: Scalars['PRN']['output'];
+    rows: Scalars['Int']['output'];
+    stage: Stage;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type GridBlueprintedInstancesArgs = {
+    where?: InputMaybe<Array<GridsFilterInput>>;
+};
+export type GridGridPlacementsArgs = {
+    where?: InputMaybe<Array<GridPlacementsFilterInput>>;
+};
+export type GridDefinition = {
+    __typename?: 'GridDefinition';
+    buildingBlock: BuildingBlock;
+    createdAt: Scalars['DateTime']['output'];
+    maxRows: Scalars['Int']['output'];
+    organization?: Maybe<Organization>;
+    prn: Scalars['PRN']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type GridPlacement = {
+    __typename?: 'GridPlacement';
+    blueprintedBy?: Maybe<GridPlacement>;
+    blueprintedInstances?: Maybe<Array<GridPlacement>>;
+    createdAt: Scalars['DateTime']['output'];
+    experienceComponent: ExperienceComponent;
+    grid: Grid;
+    organization?: Maybe<Organization>;
+    prn: Scalars['PRN']['output'];
+    row: Scalars['Int']['output'];
+    stage: Stage;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type GridPlacementBlueprintedInstancesArgs = {
+    where?: InputMaybe<Array<GridPlacementsFilterInput>>;
+};
+export type GridPlacementEdge = {
+    __typename?: 'GridPlacementEdge';
+    cursor: Scalars['String']['output'];
+    node: GridPlacement;
+};
+export type GridPlacementsConnection = {
+    __typename?: 'GridPlacementsConnection';
+    edges: Array<GridPlacementEdge>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type GridPlacementsFilterInput = {
+    _not?: InputMaybe<Array<GridPlacementsFilterInput>>;
+    createdAt?: InputMaybe<Array<DateFilter>>;
+    prn?: InputMaybe<Array<PrnFilter>>;
+    row?: InputMaybe<Array<IntFilter>>;
+    updatedAt?: InputMaybe<Array<DateFilter>>;
+};
+export type GridsFilterInput = {
+    _not?: InputMaybe<Array<GridsFilterInput>>;
+    createdAt?: InputMaybe<Array<DateFilter>>;
+    prn?: InputMaybe<Array<PrnFilter>>;
+    rows?: InputMaybe<Array<IntFilter>>;
+    updatedAt?: InputMaybe<Array<DateFilter>>;
+};
+export type HandleInvitationInput = {
+    prn: Scalars['PRN']['input'];
+};
+export type IntFilter = {
+    _eq?: InputMaybe<Scalars['Int']['input']>;
+    _gt?: InputMaybe<Scalars['Int']['input']>;
+    _gte?: InputMaybe<Scalars['Int']['input']>;
+    _in?: InputMaybe<Array<Scalars['Int']['input']>>;
+    _is_not_null?: InputMaybe<Scalars['Boolean']['input']>;
+    _is_null?: InputMaybe<Scalars['Boolean']['input']>;
+    _lt?: InputMaybe<Scalars['Int']['input']>;
+    _lte?: InputMaybe<Scalars['Int']['input']>;
+    _neq?: InputMaybe<Scalars['Int']['input']>;
+    _nin?: InputMaybe<Array<Scalars['Int']['input']>>;
+};
+export type Invitation = {
+    __typename?: 'Invitation';
+    createdAt: Scalars['DateTime']['output'];
+    prn: Scalars['PRN']['output'];
+    role: Role;
+    updatedAt: Scalars['DateTime']['output'];
+    userEmail: Scalars['String']['output'];
+};
+export type Mutation = {
+    __typename?: 'Mutation';
+    acceptInvitation: RoleAssignment;
+    addPlateMaintainer: Subject;
+    confirmAssetUpload: Array<Asset>;
+    copyBlueprint: Array<Blueprint>;
+    createAllowedValuesContentValidationRule: ContentValidationRule;
+    createApiToken: Array<CreateApiTokenResponse>;
+    createBlueprint: Array<Blueprint>;
+    createBlueprintFromContentExperience: Array<Blueprint>;
+    createBuildingBlock: Array<BuildingBlock>;
+    createBuildingBlockField: Array<BuildingBlockField>;
+    createBuildingBlockFieldFulfillment: Array<BuildingBlockFieldFulfillment>;
+    createChannel: Array<Channel>;
+    createContentExperienceWithExistingPathPart: Array<ContentExperience>;
+    createContentExperienceWithNewPathPart: Array<ContentExperience>;
+    createContentField: Array<ContentField>;
+    createContentItem: Array<ContentItem>;
+    createContentType: Array<ContentType>;
+    createContentValue: Array<ContentValue>;
+    createCountContentValidationRule: ContentValidationRule;
+    createDateBetweenContentValidationRule: ContentValidationRule;
+    createDecimalCountContentValidationRule: ContentValidationRule;
+    createExperienceComponent: Array<ExperienceComponent>;
+    createGlobalExperienceComponent: Array<ExperienceComponent>;
+    createGrid: Array<Grid>;
+    createGridDefinition: Array<GridDefinition>;
+    createGridPlacement: Array<GridPlacement>;
+    createInvitation: Array<Invitation>;
+    createNumberBetweenContentValidationRule: ContentValidationRule;
+    createOrganization: Organization;
+    createPathPartFromParent: Array<PathPart>;
+    createPathPartFromPath: Array<PathPart>;
+    createRelatableContentTypesContentValidationRule: ContentValidationRule;
+    createStringFormatContentValidationRule: ContentValidationRule;
+    createTheme: Array<Theme>;
+    createValueTypeContentValidationRule: ContentValidationRule;
+    declineInvitation: Invitation;
+    generateAssetUploadUrl: Array<GeneratedUploadUrl>;
+    regenerateApiToken: Array<CreateApiTokenResponse>;
+    removeApiToken: Array<ApiToken>;
+    removeBlueprint: Array<Blueprint>;
+    removeBuildingBlock: Array<BuildingBlock>;
+    removeBuildingBlockField: Array<BuildingBlockField>;
+    removeBuildingBlockFieldFulfillment: Array<BuildingBlockFieldFulfillment>;
+    removeChannel: Array<Channel>;
+    removeContentExperience: Array<ContentExperience>;
+    removeContentField: Array<ContentField>;
+    removeContentItem: Array<ContentItem>;
+    removeContentType: Array<ContentType>;
+    removeContentValidationRule: Array<ContentValidationRule>;
+    removeContentValue: Array<ContentValue>;
+    removeExperienceComponent: Array<ExperienceComponent>;
+    removeGrid: Array<Grid>;
+    removeGridDefinition: Array<GridDefinition>;
+    removeGridPlacement: Array<GridPlacement>;
+    removeInvitation: Array<Invitation>;
+    removeOrganization: Array<Organization>;
+    removePathPart: Array<PathPart>;
+    removePlateMaintainer: Subject;
+    removeRoleAssignment: Array<RoleAssignment>;
+    removeTheme: Array<Theme>;
+    runSeeder: Scalars['Boolean']['output'];
+    syncBlueprint: Scalars['Boolean']['output'];
+    updateAllowedValuesContentValidationRule: ContentValidationRule;
+    updateApiToken: Array<ApiToken>;
+    updateAsset: Array<Asset>;
+    updateBlueprint: Array<Blueprint>;
+    updateBuildingBlock: Array<BuildingBlock>;
+    updateBuildingBlockField: Array<BuildingBlockField>;
+    updateBuildingBlockFieldFulfillment: Array<BuildingBlockFieldFulfillment>;
+    updateChannel: Array<Channel>;
+    updateContentExperience: Array<ContentExperience>;
+    updateContentField: Array<ContentField>;
+    updateContentItem: Array<ContentItem>;
+    updateContentType: Array<ContentType>;
+    updateContentValue: Array<ContentValue>;
+    updateCountContentValidationRule: ContentValidationRule;
+    updateDateBetweenContentValidationRule: ContentValidationRule;
+    updateDecimalCountContentValidationRule: ContentValidationRule;
+    updateExperienceComponent: Array<ExperienceComponent>;
+    updateGrid: Array<Grid>;
+    updateGridDefinition: Array<GridDefinition>;
+    updateGridPlacement: Array<GridPlacement>;
+    updateNumberBetweenContentValidationRule: ContentValidationRule;
+    updateOrganization: Array<Organization>;
+    updatePathPart: Array<PathPart>;
+    updatePathPartFromPath: Array<PathPart>;
+    updateRelatableContentTypesContentValidationRule: ContentValidationRule;
+    updateStringFormatContentValidationRule: ContentValidationRule;
+    updateTheme: Array<Theme>;
+    updateValueTypeContentValidationRule: ContentValidationRule;
+};
+export type MutationAcceptInvitationArgs = {
+    input: HandleInvitationInput;
+};
+export type MutationAddPlateMaintainerArgs = {
+    email: Scalars['String']['input'];
+};
+export type MutationConfirmAssetUploadArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationCopyBlueprintArgs = {
+    input: Array<CopyBlueprintInput>;
+};
+export type MutationCreateAllowedValuesContentValidationRuleArgs = {
+    input: CreateAllowedValuesContentValidationRuleInput;
+};
+export type MutationCreateApiTokenArgs = {
+    input: Array<CreateApiTokenInput>;
+};
+export type MutationCreateBlueprintArgs = {
+    input: Array<CreateBlueprintInput>;
+};
+export type MutationCreateBlueprintFromContentExperienceArgs = {
+    input: Array<CreateBlueprintFromContentExperienceInput>;
+};
+export type MutationCreateBuildingBlockArgs = {
+    input: Array<CreateBuildingBlockInput>;
+};
+export type MutationCreateBuildingBlockFieldArgs = {
+    input: Array<CreateBuildingBlockFieldInput>;
+};
+export type MutationCreateBuildingBlockFieldFulfillmentArgs = {
+    input: Array<CreateBuildingBlockFieldFulfillmentInput>;
+};
+export type MutationCreateChannelArgs = {
+    input: Array<CreateChannelInput>;
+};
+export type MutationCreateContentExperienceWithExistingPathPartArgs = {
+    input: Array<CreateContentExperienceWithExistingPathPartInput>;
+};
+export type MutationCreateContentExperienceWithNewPathPartArgs = {
+    input: Array<CreateContentExperienceWithNewPathPartInput>;
+};
+export type MutationCreateContentFieldArgs = {
+    input: Array<CreateContentFieldInput>;
+};
+export type MutationCreateContentItemArgs = {
+    input: Array<CreateContentItemInput>;
+};
+export type MutationCreateContentTypeArgs = {
+    input: Array<CreateContentTypeInput>;
+};
+export type MutationCreateContentValueArgs = {
+    input: Array<CreateContentValueInput>;
+};
+export type MutationCreateCountContentValidationRuleArgs = {
+    input: CreateCountContentValidationRuleInput;
+};
+export type MutationCreateDateBetweenContentValidationRuleArgs = {
+    input: CreateDateBetweenContentValidationRuleInput;
+};
+export type MutationCreateDecimalCountContentValidationRuleArgs = {
+    input: CreateDecimalCountContentValidationRuleInput;
+};
+export type MutationCreateExperienceComponentArgs = {
+    input: Array<CreateExperienceComponentInput>;
+};
+export type MutationCreateGlobalExperienceComponentArgs = {
+    input: Array<CreateGlobalExperienceComponentInput>;
+};
+export type MutationCreateGridArgs = {
+    input: Array<CreateGridInput>;
+};
+export type MutationCreateGridDefinitionArgs = {
+    input: Array<CreateGridDefinitionInput>;
+};
+export type MutationCreateGridPlacementArgs = {
+    input: Array<CreateGridPlacementInput>;
+};
+export type MutationCreateInvitationArgs = {
+    input: Array<CreateInvitationInput>;
+};
+export type MutationCreateNumberBetweenContentValidationRuleArgs = {
+    input: CreateNumberBetweenContentValidationRuleInput;
+};
+export type MutationCreateOrganizationArgs = {
+    input: CreateOrganizationInput;
+};
+export type MutationCreatePathPartFromParentArgs = {
+    input: Array<CreatePathPartFromParentInput>;
+};
+export type MutationCreatePathPartFromPathArgs = {
+    input: Array<CreatePathPartFromPathInput>;
+};
+export type MutationCreateRelatableContentTypesContentValidationRuleArgs = {
+    input: CreateRelatableContentTypesContentValidationRuleInput;
+};
+export type MutationCreateStringFormatContentValidationRuleArgs = {
+    input: CreateStringFormatContentValidationRuleInput;
+};
+export type MutationCreateThemeArgs = {
+    input: Array<CreateThemeInput>;
+};
+export type MutationCreateValueTypeContentValidationRuleArgs = {
+    input: CreateValueTypeContentValidationRuleInput;
+};
+export type MutationDeclineInvitationArgs = {
+    input: HandleInvitationInput;
+};
+export type MutationGenerateAssetUploadUrlArgs = {
+    input: Array<GenerateAssetUploadUrlInput>;
+};
+export type MutationRegenerateApiTokenArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRemoveApiTokenArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRemoveBlueprintArgs = {
+    input: Array<RemoveBlueprintInput>;
+};
+export type MutationRemoveBuildingBlockArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRemoveBuildingBlockFieldArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRemoveBuildingBlockFieldFulfillmentArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRemoveChannelArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRemoveContentExperienceArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRemoveContentFieldArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRemoveContentItemArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRemoveContentTypeArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRemoveContentValidationRuleArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRemoveContentValueArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRemoveExperienceComponentArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRemoveGridArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRemoveGridDefinitionArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRemoveGridPlacementArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRemoveInvitationArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRemoveOrganizationArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRemovePathPartArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRemovePlateMaintainerArgs = {
+    id: Scalars['String']['input'];
+};
+export type MutationRemoveRoleAssignmentArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRemoveThemeArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationRunSeederArgs = {
+    seedType: SeedType;
+};
+export type MutationSyncBlueprintArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type MutationUpdateAllowedValuesContentValidationRuleArgs = {
+    input: UpdateAllowedValuesContentValidationRuleInput;
+};
+export type MutationUpdateApiTokenArgs = {
+    input: Array<UpdateApiTokenInput>;
+};
+export type MutationUpdateAssetArgs = {
+    input: Array<UpdateAssetInput>;
+};
+export type MutationUpdateBlueprintArgs = {
+    input: Array<UpdateBlueprintInput>;
+};
+export type MutationUpdateBuildingBlockArgs = {
+    input: Array<UpdateBuildingBlockInput>;
+};
+export type MutationUpdateBuildingBlockFieldArgs = {
+    input: Array<UpdateBuildingBlockFieldInput>;
+};
+export type MutationUpdateBuildingBlockFieldFulfillmentArgs = {
+    input: Array<UpdateBuildingBlockFieldFulfillmentInput>;
+};
+export type MutationUpdateChannelArgs = {
+    input: Array<UpdateChannelInput>;
+};
+export type MutationUpdateContentExperienceArgs = {
+    input: Array<UpdateContentExperienceInput>;
+};
+export type MutationUpdateContentFieldArgs = {
+    input: Array<UpdateContentFieldInput>;
+};
+export type MutationUpdateContentItemArgs = {
+    input: Array<UpdateContentItemInput>;
+};
+export type MutationUpdateContentTypeArgs = {
+    input: Array<UpdateContentTypeInput>;
+};
+export type MutationUpdateContentValueArgs = {
+    input: Array<UpdateContentValueInput>;
+};
+export type MutationUpdateCountContentValidationRuleArgs = {
+    input: UpdateCountContentValidationRuleInput;
+};
+export type MutationUpdateDateBetweenContentValidationRuleArgs = {
+    input: UpdateDateBetweenContentValidationRuleInput;
+};
+export type MutationUpdateDecimalCountContentValidationRuleArgs = {
+    input: UpdateDecimalCountContentValidationRuleInput;
+};
+export type MutationUpdateExperienceComponentArgs = {
+    input: Array<UpdateExperienceComponentInput>;
+};
+export type MutationUpdateGridArgs = {
+    input: Array<UpdateGridInput>;
+};
+export type MutationUpdateGridDefinitionArgs = {
+    input: Array<UpdateGridDefinitionInput>;
+};
+export type MutationUpdateGridPlacementArgs = {
+    input: Array<UpdateGridPlacementInput>;
+};
+export type MutationUpdateNumberBetweenContentValidationRuleArgs = {
+    input: UpdateNumberBetweenContentValidationRuleInput;
+};
+export type MutationUpdateOrganizationArgs = {
+    input: Array<UpdateOrganizationInput>;
+};
+export type MutationUpdatePathPartArgs = {
+    input: Array<UpdatePathPartInput>;
+};
+export type MutationUpdatePathPartFromPathArgs = {
+    input: Array<UpdatePathPartByPathInput>;
+};
+export type MutationUpdateRelatableContentTypesContentValidationRuleArgs = {
+    input: UpdateRelatableContentTypesContentValidationRuleInput;
+};
+export type MutationUpdateStringFormatContentValidationRuleArgs = {
+    input: UpdateStringFormatContentValidationRuleInput;
+};
+export type MutationUpdateThemeArgs = {
+    input: Array<UpdateThemeInput>;
+};
+export type MutationUpdateValueTypeContentValidationRuleArgs = {
+    input: UpdateValueTypeContentValidationRuleInput;
+};
+export type Name = {
+    __typename?: 'Name';
+    first: Scalars['String']['output'];
+    last: Scalars['String']['output'];
+};
+export type NumberBetweenContentValidationRuleSettings = {
+    __typename?: 'NumberBetweenContentValidationRuleSettings';
+    max: Scalars['Int']['output'];
+    min: Scalars['Int']['output'];
+};
+export type NumberBetweenContentValidationRuleSettingsInput = {
+    max: Scalars['Int']['input'];
+    min: Scalars['Int']['input'];
+};
+export type OrderOptionsInput = {
+    direction?: InputMaybe<SortingDirection>;
+    key?: InputMaybe<Scalars['String']['input']>;
+};
+export type Organization = {
+    __typename?: 'Organization';
+    createdAt: Scalars['DateTime']['output'];
+    logo?: Maybe<Asset>;
+    logoUrl?: Maybe<Scalars['String']['output']>;
+    name: Scalars['String']['output'];
+    prn: Scalars['PRN']['output'];
+    roles: Array<Role>;
+    seedStatus: SeedStatus;
+    slug: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+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 PaginationOptionsInput = {
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+};
+export type PathPart = {
+    __typename?: 'PathPart';
+    channel: Channel;
+    children: Array<PathPart>;
+    contentExperience?: Maybe<ContentExperience>;
+    createdAt: Scalars['DateTime']['output'];
+    organization?: Maybe<Organization>;
+    parent?: Maybe<PathPart>;
+    path: Scalars['String']['output'];
+    prn: Scalars['PRN']['output'];
+    slug: Scalars['String']['output'];
+    stage: Stage;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type PathPartChildrenArgs = {
+    where?: InputMaybe<Array<PathPartsFilterInput>>;
+};
+export type PathPartEdge = {
+    __typename?: 'PathPartEdge';
+    cursor: Scalars['String']['output'];
+    node: PathPart;
+};
+export type PathPartsConnection = {
+    __typename?: 'PathPartsConnection';
+    edges: Array<PathPartEdge>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type PathPartsFilterInput = {
+    _not?: InputMaybe<Array<PathPartsFilterInput>>;
+    createdAt?: InputMaybe<Array<DateFilter>>;
+    prn?: InputMaybe<Array<PrnFilter>>;
+    slug?: InputMaybe<Array<StringFilter>>;
+    updatedAt?: InputMaybe<Array<DateFilter>>;
+};
+export type PrnFilter = {
+    _eq?: InputMaybe<Scalars['PRN']['input']>;
+    _in?: InputMaybe<Array<Scalars['PRN']['input']>>;
+    _is_not_null?: InputMaybe<Scalars['Boolean']['input']>;
+    _is_null?: InputMaybe<Scalars['Boolean']['input']>;
+    _neq?: InputMaybe<Scalars['PRN']['input']>;
+    _nin?: InputMaybe<Array<Scalars['PRN']['input']>>;
+};
+export type Query = {
+    __typename?: 'Query';
+    apiToken: Array<ApiToken>;
+    apiTokens: Array<ApiToken>;
+    blueprint: Array<Blueprint>;
+    blueprints: BlueprintsConnection;
+    buildingBlock: Array<BuildingBlock>;
+    buildingBlockField: Array<BuildingBlockField>;
+    buildingBlockFieldFulfillment: Array<BuildingBlockFieldFulfillment>;
+    buildingBlockFieldFulfillments: BuildingBlockFieldFulfillmentsConnection;
+    buildingBlockFields: BuildingBlockFieldsConnection;
+    channel: Array<Channel>;
+    channels: ChannelsConnection;
+    contentExperience: Array<ContentExperience>;
+    contentExperienceByPath: Array<ContentExperience>;
+    contentExperiences: ContentExperiencesConnection;
+    contentField: Array<ContentField>;
+    contentFields: ContentFieldsConnection;
+    contentItem: Array<ContentItem>;
+    contentItems: ContentItemsConnection;
+    contentType: Array<ContentType>;
+    contentTypes: ContentTypesConnection;
+    contentValue: Array<ContentValue>;
+    contentValues: ContentValuesConnection;
+    currentSubject: Subject;
+    experienceComponent: Array<ExperienceComponent>;
+    experienceComponents: ExperienceComponentsConnection;
+    grid: Array<Grid>;
+    gridDefinition: Array<GridDefinition>;
+    gridPlacement: Array<GridPlacement>;
+    gridPlacements: GridPlacementsConnection;
+    invitation: Array<Invitation>;
+    invitationsForCurrentSubject: Array<Invitation>;
+    invitationsForOrganization: Array<Invitation>;
+    organization: Array<Organization>;
+    pathPart: Array<PathPart>;
+    pathPartByPath: Array<PathPart>;
+    pathParts: PathPartsConnection;
+    plateMaintainers: Array<Subject>;
+    roleAssignmentsForCurrentSubject: Array<RoleAssignment>;
+    roleAssignmentsForOrganization: Array<RoleAssignment>;
+    theme: Array<Theme>;
+    themes: ThemesConnection;
+};
+export type QueryApiTokenArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type QueryApiTokensArgs = {
+    orderBy?: InputMaybe<OrderOptionsInput>;
+};
+export type QueryBlueprintArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type QueryBlueprintsArgs = {
+    orderBy?: InputMaybe<OrderOptionsInput>;
+    paginate: PaginationOptionsInput;
+    where?: InputMaybe<Array<BlueprintsFilterInput>>;
+};
+export type QueryBuildingBlockArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type QueryBuildingBlockFieldArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type QueryBuildingBlockFieldFulfillmentArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type QueryBuildingBlockFieldFulfillmentsArgs = {
+    orderBy?: InputMaybe<OrderOptionsInput>;
+    paginate: PaginationOptionsInput;
+    where?: InputMaybe<Array<BuildingBlockFieldFulfillmentsFilterInput>>;
+};
+export type QueryBuildingBlockFieldsArgs = {
+    orderBy?: InputMaybe<OrderOptionsInput>;
+    paginate: PaginationOptionsInput;
+    where?: InputMaybe<Array<BuildingBlockFieldsFilterInput>>;
+};
+export type QueryChannelArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type QueryChannelsArgs = {
+    orderBy?: InputMaybe<OrderOptionsInput>;
+    paginate: PaginationOptionsInput;
+    where?: InputMaybe<Array<ChannelsFilterInput>>;
+};
+export type QueryContentExperienceArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type QueryContentExperienceByPathArgs = {
+    input: Array<FindPathPartByPathInput>;
+};
+export type QueryContentExperiencesArgs = {
+    orderBy?: InputMaybe<OrderOptionsInput>;
+    paginate: PaginationOptionsInput;
+    where?: InputMaybe<Array<ContentExperiencesFilterInput>>;
+};
+export type QueryContentFieldArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type QueryContentFieldsArgs = {
+    orderBy?: InputMaybe<OrderOptionsInput>;
+    paginate: PaginationOptionsInput;
+    where?: InputMaybe<Array<ContentFieldsFilterInput>>;
+};
+export type QueryContentItemArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type QueryContentItemsArgs = {
+    orderBy?: InputMaybe<OrderOptionsInput>;
+    paginate: PaginationOptionsInput;
+    where?: InputMaybe<Array<ContentItemsFilterInput>>;
+};
+export type QueryContentTypeArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type QueryContentTypesArgs = {
+    orderBy?: InputMaybe<OrderOptionsInput>;
+    paginate: PaginationOptionsInput;
+    where?: InputMaybe<Array<ContentTypesFilterInput>>;
+};
+export type QueryContentValueArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type QueryContentValuesArgs = {
+    orderBy?: InputMaybe<OrderOptionsInput>;
+    paginate: PaginationOptionsInput;
+    where?: InputMaybe<Array<ContentValuesFilterInput>>;
+};
+export type QueryExperienceComponentArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type QueryExperienceComponentsArgs = {
+    orderBy?: InputMaybe<OrderOptionsInput>;
+    paginate: PaginationOptionsInput;
+    where?: InputMaybe<Array<ExperienceComponentsFilterInput>>;
+};
+export type QueryGridArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type QueryGridDefinitionArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type QueryGridPlacementArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type QueryGridPlacementsArgs = {
+    orderBy?: InputMaybe<OrderOptionsInput>;
+    paginate: PaginationOptionsInput;
+    where?: InputMaybe<Array<GridPlacementsFilterInput>>;
+};
+export type QueryInvitationArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type QueryOrganizationArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type QueryPathPartArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type QueryPathPartByPathArgs = {
+    input: Array<FindPathPartByPathInput>;
+};
+export type QueryPathPartsArgs = {
+    orderBy?: InputMaybe<OrderOptionsInput>;
+    paginate: PaginationOptionsInput;
+    where?: InputMaybe<Array<PathPartsFilterInput>>;
+};
+export type QueryThemeArgs = {
+    prn: Array<Scalars['PRN']['input']>;
+};
+export type QueryThemesArgs = {
+    orderBy?: InputMaybe<OrderOptionsInput>;
+    paginate: PaginationOptionsInput;
+    where?: InputMaybe<Array<ThemesFilterInput>>;
+};
+export type RelatableContentTypesContentValidationRuleSettings = {
+    __typename?: 'RelatableContentTypesContentValidationRuleSettings';
+    allowedContentTypes: Array<Scalars['PRN']['output']>;
+};
+export type RelatableContentTypesContentValidationRuleSettingsInput = {
+    allowedContentTypes: Array<Scalars['PRN']['input']>;
+};
+export type RemoveBlueprintInput = {
+    prn: Scalars['PRN']['input'];
+    removeBlueprintInstanceMode?: InputMaybe<RemoveBlueprintInstanceMode>;
+};
+export declare enum RemoveBlueprintInstanceMode {
+    Disconnect = "DISCONNECT",
+    Remove = "REMOVE"
+}
+export type Role = {
+    __typename?: 'Role';
+    createdAt: Scalars['DateTime']['output'];
+    invitations: Array<Invitation>;
+    name: DefaultRoleName;
+    organization: Organization;
+    prn: Scalars['PRN']['output'];
+    roleAssignments: Array<RoleAssignment>;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type RoleAssignment = {
+    __typename?: 'RoleAssignment';
+    createdAt: Scalars['DateTime']['output'];
+    prn: Scalars['PRN']['output'];
+    role: Role;
+    subject: Subject;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export declare enum RuleType {
+    AllowedValues = "ALLOWED_VALUES",
+    Count = "COUNT",
+    DateBetween = "DATE_BETWEEN",
+    DecimalCount = "DECIMAL_COUNT",
+    NumberBetween = "NUMBER_BETWEEN",
+    RelatableContentTypes = "RELATABLE_CONTENT_TYPES",
+    StringFormat = "STRING_FORMAT",
+    ValueType = "VALUE_TYPE"
+}
+export declare enum SeedStatus {
+    Completed = "COMPLETED",
+    InProgress = "IN_PROGRESS",
+    NotStarted = "NOT_STARTED"
+}
+export declare enum SeedType {
+    Hotel = "HOTEL"
+}
+export declare enum SortingDirection {
+    Asc = "ASC",
+    Desc = "DESC"
+}
+export declare enum Stage {
+    Development = "DEVELOPMENT",
+    Production = "PRODUCTION"
+}
+export type StringFilter = {
+    _eq?: InputMaybe<Scalars['String']['input']>;
+    _ilike?: InputMaybe<Scalars['String']['input']>;
+    _in?: InputMaybe<Array<Scalars['String']['input']>>;
+    _is_not_null?: InputMaybe<Scalars['Boolean']['input']>;
+    _is_null?: InputMaybe<Scalars['Boolean']['input']>;
+    _like?: InputMaybe<Scalars['String']['input']>;
+    _neq?: InputMaybe<Scalars['String']['input']>;
+    _nin?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export type StringFormatContentValidationRuleSettings = {
+    __typename?: 'StringFormatContentValidationRuleSettings';
+    allowedFormat: Scalars['String']['output'];
+};
+export type StringFormatContentValidationRuleSettingsInput = {
+    allowedFormat: Scalars['String']['input'];
+};
+export type Subject = {
+    __typename?: 'Subject';
+    email: Scalars['String']['output'];
+    id: Scalars['String']['output'];
+    isPlateMaintainer: Scalars['Boolean']['output'];
+    language: Scalars['String']['output'];
+    name: Name;
+    roleAssignments: Array<RoleAssignment>;
+};
+export type Theme = {
+    __typename?: 'Theme';
+    buildingBlocks: Array<BuildingBlock>;
+    channels: Array<Channel>;
+    createdAt: Scalars['DateTime']['output'];
+    name: Scalars['String']['output'];
+    organization?: Maybe<Organization>;
+    prn: Scalars['PRN']['output'];
+    repositoryUrl: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type ThemeBuildingBlocksArgs = {
+    where?: InputMaybe<Array<BuildingBlocksFilterInput>>;
+};
+export type ThemeChannelsArgs = {
+    where?: InputMaybe<Array<ChannelsFilterInput>>;
+};
+export type ThemeEdge = {
+    __typename?: 'ThemeEdge';
+    cursor: Scalars['String']['output'];
+    node: Theme;
+};
+export type ThemesConnection = {
+    __typename?: 'ThemesConnection';
+    edges: Array<ThemeEdge>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type ThemesFilterInput = {
+    _not?: InputMaybe<Array<ThemesFilterInput>>;
+    createdAt?: InputMaybe<Array<DateFilter>>;
+    name?: InputMaybe<Array<StringFilter>>;
+    prn?: InputMaybe<Array<PrnFilter>>;
+    repositoryUrl?: InputMaybe<Array<StringFilter>>;
+    updatedAt?: InputMaybe<Array<DateFilter>>;
+};
+export type UpdateAllowedValuesContentValidationRuleInput = {
+    prn: Scalars['PRN']['input'];
+    settings: AllowedValuesContentValidationRuleSettingsInput;
+};
+export type UpdateApiTokenInput = {
+    name: Scalars['String']['input'];
+    prn: Scalars['PRN']['input'];
+};
+export type UpdateAssetInput = {
+    fileName?: InputMaybe<Scalars['String']['input']>;
+    prn: Scalars['PRN']['input'];
+};
+export type UpdateBlueprintInput = {
+    channel?: InputMaybe<Scalars['PRN']['input']>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    preview?: InputMaybe<Scalars['PRN']['input']>;
+    prn: Scalars['PRN']['input'];
+};
+export type UpdateBuildingBlockFieldFulfillmentInput = {
+    contentValue?: InputMaybe<Scalars['PRN']['input']>;
+    next?: InputMaybe<Scalars['PRN']['input']>;
+    prn: Scalars['PRN']['input'];
+};
+export type UpdateBuildingBlockFieldInput = {
+    fieldTypes?: InputMaybe<Array<ContentValueTypeNames>>;
+    maxCount?: InputMaybe<Scalars['Int']['input']>;
+    minCount?: InputMaybe<Scalars['Int']['input']>;
+    next?: InputMaybe<Scalars['PRN']['input']>;
+    prn: Scalars['PRN']['input'];
+    slug?: InputMaybe<Scalars['String']['input']>;
+    title?: InputMaybe<Scalars['String']['input']>;
+};
+export type UpdateBuildingBlockInput = {
+    next?: InputMaybe<Scalars['PRN']['input']>;
+    preview?: InputMaybe<Scalars['PRN']['input']>;
+    prn: Scalars['PRN']['input'];
+    slug?: InputMaybe<Scalars['String']['input']>;
+    title?: InputMaybe<Scalars['String']['input']>;
+};
+export type UpdateChannelInput = {
+    defaultBlueprint?: InputMaybe<Scalars['PRN']['input']>;
+    domain?: InputMaybe<Scalars['String']['input']>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    prn: Scalars['PRN']['input'];
+    slug?: InputMaybe<Scalars['String']['input']>;
+};
+export type UpdateContentExperienceInput = {
+    createPathPartFromParent?: InputMaybe<CreatePathPartFromParentInput>;
+    createPathPartFromPath?: InputMaybe<CreatePathPartFromPathInput>;
+    fromBlueprint?: InputMaybe<Scalars['PRN']['input']>;
+    pathPart?: InputMaybe<Scalars['PRN']['input']>;
+    preview?: InputMaybe<Scalars['PRN']['input']>;
+    prn: Scalars['PRN']['input'];
+    slug?: InputMaybe<Scalars['String']['input']>;
+    title?: InputMaybe<Scalars['String']['input']>;
+};
+export type UpdateContentFieldInput = {
+    name?: InputMaybe<Scalars['String']['input']>;
+    next?: InputMaybe<Scalars['PRN']['input']>;
+    prn: Scalars['PRN']['input'];
+};
+export type UpdateContentItemInput = {
+    contentValuesToConnect?: InputMaybe<Array<ConnectContentValueInput>>;
+    contentValuesToCreate?: InputMaybe<Array<CreateContentValueForContentItemInput>>;
+    isDraft?: InputMaybe<Scalars['Boolean']['input']>;
+    prn: Scalars['PRN']['input'];
+};
+export type UpdateContentTypeInput = {
+    displayImageField?: InputMaybe<Scalars['PRN']['input']>;
+    displayNameTemplate?: InputMaybe<Scalars['String']['input']>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    prn: Scalars['PRN']['input'];
+};
+export type UpdateContentValueInput = {
+    contentField?: InputMaybe<Scalars['PRN']['input']>;
+    contentItem?: InputMaybe<Scalars['PRN']['input']>;
+    linkedGridPlacement?: InputMaybe<Scalars['PRN']['input']>;
+    linkedPathPart?: InputMaybe<Scalars['PRN']['input']>;
+    next?: InputMaybe<Scalars['PRN']['input']>;
+    primitiveValue?: InputMaybe<Scalars['PrimitiveValue']['input']>;
+    prn: Scalars['PRN']['input'];
+    relatedAsset?: InputMaybe<Scalars['PRN']['input']>;
+    relatedContentItem?: InputMaybe<Scalars['PRN']['input']>;
+    smartText?: InputMaybe<Scalars['CAST']['input']>;
+};
+export type UpdateCountContentValidationRuleInput = {
+    prn: Scalars['PRN']['input'];
+    settings: CountContentValidationRuleSettingsInput;
+};
+export type UpdateDateBetweenContentValidationRuleInput = {
+    prn: Scalars['PRN']['input'];
+    settings: DateBetweenContentValidationRuleSettingsInput;
+};
+export type UpdateDecimalCountContentValidationRuleInput = {
+    prn: Scalars['PRN']['input'];
+    settings: DecimalCountContentValidationRuleSettingsInput;
+};
+export type UpdateExperienceComponentInput = {
+    buildingBlock?: InputMaybe<Scalars['PRN']['input']>;
+    isDraft?: InputMaybe<Scalars['Boolean']['input']>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    preview?: InputMaybe<Scalars['PRN']['input']>;
+    prn: Scalars['PRN']['input'];
+};
+export type UpdateGridDefinitionInput = {
+    maxRows?: InputMaybe<Scalars['Int']['input']>;
+    prn: Scalars['PRN']['input'];
+};
+export type UpdateGridInput = {
+    prn: Scalars['PRN']['input'];
+    rows?: InputMaybe<Scalars['Int']['input']>;
+};
+export type UpdateGridPlacementInput = {
+    prn: Scalars['PRN']['input'];
+    row?: InputMaybe<Scalars['Int']['input']>;
+};
+export type UpdateNumberBetweenContentValidationRuleInput = {
+    prn: Scalars['PRN']['input'];
+    settings: NumberBetweenContentValidationRuleSettingsInput;
+};
+export type UpdateOrganizationInput = {
+    logo?: InputMaybe<Scalars['PRN']['input']>;
+    logoUrl?: InputMaybe<Scalars['String']['input']>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    prn: Scalars['PRN']['input'];
+    slug?: InputMaybe<Scalars['String']['input']>;
+};
+export type UpdatePathPartByPathInput = {
+    path: Scalars['String']['input'];
+    prn: Scalars['PRN']['input'];
+};
+export type UpdatePathPartInput = {
+    parent?: InputMaybe<Scalars['String']['input']>;
+    prn: Scalars['PRN']['input'];
+    slug?: InputMaybe<Scalars['String']['input']>;
+};
+export type UpdateRelatableContentTypesContentValidationRuleInput = {
+    prn: Scalars['PRN']['input'];
+    settings: RelatableContentTypesContentValidationRuleSettingsInput;
+};
+export type UpdateStringFormatContentValidationRuleInput = {
+    prn: Scalars['PRN']['input'];
+    settings: StringFormatContentValidationRuleSettingsInput;
+};
+export type UpdateThemeInput = {
+    name?: InputMaybe<Scalars['String']['input']>;
+    prn: Scalars['PRN']['input'];
+    repositoryUrl?: InputMaybe<Scalars['String']['input']>;
+};
+export type UpdateValueTypeContentValidationRuleInput = {
+    prn: Scalars['PRN']['input'];
+    settings: ValueTypeContentValidationRuleSettingsInput;
+};
+export type ValueTypeContentValidationRuleSettings = {
+    __typename?: 'ValueTypeContentValidationRuleSettings';
+    allowedTypes: Array<ContentValueTypeNames>;
+};
+export type ValueTypeContentValidationRuleSettingsInput = {
+    allowedTypes: Array<ContentValueTypeNames>;
+};