@apollo/server/src/plugin/schemaReporting/generated/operations.d.ts

Core engine for Apollo GraphQL server

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; }
  Blob: { input: any; output: any; }
  Cursor: { input: any; output: any; }
  Date: { input: any; output: any; }
  DateTime: { input: any; output: any; }
  FederationVersion: { input: any; output: any; }
  GraphQLDocument: { input: any; output: any; }
  JSON: { input: any; output: any; }
  Long: { input: any; output: any; }
  NaiveDateTime: { input: any; output: any; }
  Object: { input: any; output: any; }
  SHA256: { input: any; output: any; }
  StringOrInt: { input: any; output: any; }
  Timestamp: { input: any; output: any; }
  Void: { input: any; output: any; }
};

/** An organization in Apollo Studio. Can have multiple members and graphs. */
export type Account = {
  __typename?: 'Account';
  auditLogExports?: Maybe<Array<AuditLogExport>>;
  /** These are the roles that the account is able to use */
  availableRoles: Array<UserPermission>;
  /**
   * Get an URL to which an avatar image can be uploaded. Client uploads by sending a PUT request
   * with the image data to MediaUploadInfo.url. Client SHOULD set the "Content-Type" header to the
   * browser-inferred MIME type, and SHOULD set the "x-apollo-content-filename" header to the
   * filename, if such information is available. Client MUST set the "x-apollo-csrf-token" header to
   * MediaUploadInfo.csrfToken.
   */
  avatarUpload?: Maybe<AvatarUploadResult>;
  /**
   * Get an image URL for the account's avatar. Note that CORS is not enabled for these URLs. The size
   * argument is used for bandwidth reduction, and should be the size of the image as displayed in the
   * application. Apollo's media server will downscale larger images to at least the requested size,
   * but this will not happen for third-party media servers.
   */
  avatarUrl?: Maybe<Scalars['String']['output']>;
  billingContactEmail?: Maybe<Scalars['String']['output']>;
  billingInfo?: Maybe<BillingInfo>;
  billingInsights: BillingInsights;
  capabilities?: Maybe<AccountCapabilities>;
  /** Fetch a CloudOnboarding associated with this account */
  cloudOnboarding?: Maybe<CloudOnboarding>;
  companyUrl?: Maybe<Scalars['String']['output']>;
  /** The time at which the account was created */
  createdAt?: Maybe<Scalars['Timestamp']['output']>;
  currentBillingMonth?: Maybe<BillingMonth>;
  currentPlan: BillingPlan;
  currentSubscription?: Maybe<BillingSubscription>;
  eligibleForUsageBasedPlan: Scalars['Boolean']['output'];
  expiredTrialDismissedAt?: Maybe<Scalars['Timestamp']['output']>;
  expiredTrialSubscription?: Maybe<BillingSubscription>;
  graphIDAvailable: Scalars['Boolean']['output'];
  /** Graphs belonging to this organization. */
  graphs: Array<Service>;
  /** Graphs belonging to this organization. */
  graphsConnection?: Maybe<AccountGraphConnection>;
  hasBeenOnTrial: Scalars['Boolean']['output'];
  hasBillingInfo?: Maybe<Scalars['Boolean']['output']>;
  /** Globally unique identifier, which isn't guaranteed stable (can be changed by administrators). */
  id: Scalars['ID']['output'];
  /**
   * Internal immutable identifier for the account. Only visible to Apollo admins (because it really
   * shouldn't be used in normal client apps).
   */
  internalID: Scalars['ID']['output'];
  invitations?: Maybe<Array<AccountInvitation>>;
  invoices: Array<Invoice>;
  isLocked?: Maybe<Scalars['Boolean']['output']>;
  isOnExpiredTrial: Scalars['Boolean']['output'];
  isOnTrial: Scalars['Boolean']['output'];
  isSelfServiceDeletable?: Maybe<Scalars['Boolean']['output']>;
  limits?: Maybe<AccountLimits>;
  lockDetails?: Maybe<AccountLockDetails>;
  /** The user memberships belonging to an Organization */
  memberships?: Maybe<Array<AccountMembership>>;
  /** Name of the organization, which can change over time and isn't unique. */
  name: Scalars['String']['output'];
  /**
   * Fetches an offline license for the account.
   * (If you need this then please contact your Apollo account manager to discuss your requirements.)
   */
  offlineLicense?: Maybe<RouterEntitlement>;
  /**
   * Fetches usage based pricing operations counts for the calling user. If a particular window is not specified,
   * totals for the user's current billing period are returned. (Will error if the user is not currently on a usage
   * based plan.)
   */
  operationUsage: AccountOperationUsage;
  /** List the private subgraphs associated with your Apollo account */
  privateSubgraphs: Array<PrivateSubgraph>;
  /** @deprecated use Account.createdAt instead */
  provisionedAt?: Maybe<Scalars['Timestamp']['output']>;
  /** Returns a different registry related stats pertaining to this account. */
  registryStatsWindow?: Maybe<RegistryStatsWindow>;
  requests?: Maybe<Scalars['Long']['output']>;
  requestsInCurrentBillingPeriod?: Maybe<Scalars['Long']['output']>;
  roles?: Maybe<AccountRoles>;
  routerEntitlement?: Maybe<RouterEntitlement>;
  /** How many seats would be included in your next bill, as best estimated today */
  seatCountForNextBill?: Maybe<Scalars['Int']['output']>;
  seats?: Maybe<Seats>;
  secondaryIDs: Array<Scalars['ID']['output']>;
  /**
   * Graphs belonging to this organization.
   * @deprecated Use graphs field instead
   */
  services: Array<Service>;
  /** The session length in seconds for a user in this org */
  sessionDurationInSeconds?: Maybe<Scalars['Int']['output']>;
  /**
   * If non-null, this organization tracks its members through an upstream IdP;
   * invitations are not possible on SSO-synchronized account.
   */
  sso?: Maybe<OrganizationSso>;
  ssoV2?: Maybe<SsoConfig>;
  /** @deprecated no longer relevant; it's only ever populated for enterprise accounts */
  state?: Maybe<AccountState>;
  /** A list of reusable invitations for the organization. */
  staticInvitations?: Maybe<Array<OrganizationInviteLink>>;
  /** @deprecated use Account.statsWindow instead */
  stats: AccountStatsWindow;
  statsWindow?: Maybe<AccountStatsWindow>;
  subscriptions: Array<BillingSubscription>;
  /** Gets a ticket for this org, by id */
  supportTicket?: Maybe<SupportTicket>;
  /** List of support tickets submitted for this org */
  supportTickets?: Maybe<Array<SupportTicket>>;
  survey?: Maybe<Survey>;
  /**
   * All Variants within the Graphs belonging to this organization. Can be limited to those favorited by the current user.
   * @deprecated use Service.variants instead
   */
  variants?: Maybe<AccountGraphVariantConnection>;
};


/** An organization in Apollo Studio. Can have multiple members and graphs. */
export type AccountAvatarUrlArgs = {
  size?: Scalars['Int']['input'];
};


/** An organization in Apollo Studio. Can have multiple members and graphs. */
export type AccountBillingInsightsArgs = {
  from: Scalars['Date']['input'];
  limit?: InputMaybe<Scalars['Int']['input']>;
  to?: InputMaybe<Scalars['Date']['input']>;
  windowSize?: InputMaybe<BillingUsageStatsWindowSize>;
};


/** An organization in Apollo Studio. Can have multiple members and graphs. */
export type AccountCloudOnboardingArgs = {
  graphRef: Scalars['String']['input'];
};


/** An organization in Apollo Studio. Can have multiple members and graphs. */
export type AccountGraphIdAvailableArgs = {
  id: Scalars['ID']['input'];
};


/** An organization in Apollo Studio. Can have multiple members and graphs. */
export type AccountGraphsArgs = {
  filterBy?: InputMaybe<GraphFilter>;
  includeDeleted?: InputMaybe<Scalars['Boolean']['input']>;
};


/** An organization in Apollo Studio. Can have multiple members and graphs. */
export type AccountGraphsConnectionArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  filterBy?: InputMaybe<GraphFilter>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
};


/** An organization in Apollo Studio. Can have multiple members and graphs. */
export type AccountInvitationsArgs = {
  includeAccepted?: Scalars['Boolean']['input'];
};


/** An organization in Apollo Studio. Can have multiple members and graphs. */
export type AccountOperationUsageArgs = {
  forWindow?: InputMaybe<AccountOperationUsageWindowInput>;
};


/** An organization in Apollo Studio. Can have multiple members and graphs. */
export type AccountPrivateSubgraphsArgs = {
  cloudProvider: CloudProvider;
};


/** An organization in Apollo Studio. Can have multiple members and graphs. */
export type AccountRegistryStatsWindowArgs = {
  from: Scalars['Timestamp']['input'];
  resolution?: InputMaybe<Resolution>;
  to?: InputMaybe<Scalars['Timestamp']['input']>;
};


/** An organization in Apollo Studio. Can have multiple members and graphs. */
export type AccountRequestsArgs = {
  from: Scalars['Timestamp']['input'];
  to: Scalars['Timestamp']['input'];
};


/** An organization in Apollo Studio. Can have multiple members and graphs. */
export type AccountServicesArgs = {
  includeDeleted?: InputMaybe<Scalars['Boolean']['input']>;
};


/** An organization in Apollo Studio. Can have multiple members and graphs. */
export type AccountStatsArgs = {
  from: Scalars['Timestamp']['input'];
  resolution?: InputMaybe<Resolution>;
  to?: InputMaybe<Scalars['Timestamp']['input']>;
};


/** An organization in Apollo Studio. Can have multiple members and graphs. */
export type AccountStatsWindowArgs = {
  from: Scalars['Timestamp']['input'];
  resolution?: InputMaybe<Resolution>;
  to?: InputMaybe<Scalars['Timestamp']['input']>;
};


/** An organization in Apollo Studio. Can have multiple members and graphs. */
export type AccountSupportTicketArgs = {
  id: Scalars['ID']['input'];
};


/** An organization in Apollo Studio. Can have multiple members and graphs. */
export type AccountSurveyArgs = {
  id: Scalars['String']['input'];
};


/** An organization in Apollo Studio. Can have multiple members and graphs. */
export type AccountVariantsArgs = {
  filterBy?: InputMaybe<GraphVariantFilter>;
};

/** Columns of AccountBillingUsageStats. */
export enum AccountBillingUsageStatsColumn {
  AGENT_ID = 'AGENT_ID',
  AGENT_VERSION = 'AGENT_VERSION',
  GRAPH_DEPLOYMENT_TYPE = 'GRAPH_DEPLOYMENT_TYPE',
  OPERATION_COUNT = 'OPERATION_COUNT',
  OPERATION_COUNT_PROVIDED_EXPLICITLY = 'OPERATION_COUNT_PROVIDED_EXPLICITLY',
  OPERATION_SUBTYPE = 'OPERATION_SUBTYPE',
  OPERATION_TYPE = 'OPERATION_TYPE',
  ROUTER_FEATURES_ENABLED = 'ROUTER_FEATURES_ENABLED',
  SCHEMA_TAG = 'SCHEMA_TAG',
  SERVICE_ID = 'SERVICE_ID',
  TIMESTAMP = 'TIMESTAMP'
}

export type AccountBillingUsageStatsDimensions = {
  __typename?: 'AccountBillingUsageStatsDimensions';
  agentId?: Maybe<Scalars['String']['output']>;
  agentVersion?: Maybe<Scalars['String']['output']>;
  graphDeploymentType?: Maybe<Scalars['String']['output']>;
  operationCountProvidedExplicitly?: Maybe<Scalars['String']['output']>;
  operationSubtype?: Maybe<Scalars['String']['output']>;
  operationType?: Maybe<Scalars['String']['output']>;
  routerFeaturesEnabled?: Maybe<Scalars['String']['output']>;
  schemaTag?: Maybe<Scalars['String']['output']>;
  serviceId?: Maybe<Scalars['ID']['output']>;
};

/** Filter for data in AccountBillingUsageStats. Fields with dimension names represent equality checks. All fields are implicitly ANDed together. */
export type AccountBillingUsageStatsFilter = {
  /** Selects rows whose agentId dimension equals the given value if not null. To query for the null value, use {in: {agentId: [null]}} instead. */
  agentId?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose agentVersion dimension equals the given value if not null. To query for the null value, use {in: {agentVersion: [null]}} instead. */
  agentVersion?: InputMaybe<Scalars['String']['input']>;
  and?: InputMaybe<Array<AccountBillingUsageStatsFilter>>;
  /** Selects rows whose graphDeploymentType dimension equals the given value if not null. To query for the null value, use {in: {graphDeploymentType: [null]}} instead. */
  graphDeploymentType?: InputMaybe<Scalars['String']['input']>;
  in?: InputMaybe<AccountBillingUsageStatsFilterIn>;
  not?: InputMaybe<AccountBillingUsageStatsFilter>;
  /** Selects rows whose operationCountProvidedExplicitly dimension equals the given value if not null. To query for the null value, use {in: {operationCountProvidedExplicitly: [null]}} instead. */
  operationCountProvidedExplicitly?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose operationSubtype dimension equals the given value if not null. To query for the null value, use {in: {operationSubtype: [null]}} instead. */
  operationSubtype?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose operationType dimension equals the given value if not null. To query for the null value, use {in: {operationType: [null]}} instead. */
  operationType?: InputMaybe<Scalars['String']['input']>;
  or?: InputMaybe<Array<AccountBillingUsageStatsFilter>>;
  /** Selects rows whose routerFeaturesEnabled dimension equals the given value if not null. To query for the null value, use {in: {routerFeaturesEnabled: [null]}} instead. */
  routerFeaturesEnabled?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose schemaTag dimension equals the given value if not null. To query for the null value, use {in: {schemaTag: [null]}} instead. */
  schemaTag?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose serviceId dimension equals the given value if not null. To query for the null value, use {in: {serviceId: [null]}} instead. */
  serviceId?: InputMaybe<Scalars['ID']['input']>;
};

/** Filter for data in AccountBillingUsageStats. Fields match if the corresponding dimension's value is in the given list. All fields are implicitly ANDed together. */
export type AccountBillingUsageStatsFilterIn = {
  /** Selects rows whose agentId dimension is in the given list. A null value in the list means a row with null for that dimension. */
  agentId?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose agentVersion dimension is in the given list. A null value in the list means a row with null for that dimension. */
  agentVersion?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose graphDeploymentType dimension is in the given list. A null value in the list means a row with null for that dimension. */
  graphDeploymentType?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose operationCountProvidedExplicitly dimension is in the given list. A null value in the list means a row with null for that dimension. */
  operationCountProvidedExplicitly?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose operationSubtype dimension is in the given list. A null value in the list means a row with null for that dimension. */
  operationSubtype?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose operationType dimension is in the given list. A null value in the list means a row with null for that dimension. */
  operationType?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose routerFeaturesEnabled dimension is in the given list. A null value in the list means a row with null for that dimension. */
  routerFeaturesEnabled?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose schemaTag dimension is in the given list. A null value in the list means a row with null for that dimension. */
  schemaTag?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose serviceId dimension is in the given list. A null value in the list means a row with null for that dimension. */
  serviceId?: InputMaybe<Array<InputMaybe<Scalars['ID']['input']>>>;
};

export type AccountBillingUsageStatsMetrics = {
  __typename?: 'AccountBillingUsageStatsMetrics';
  operationCount: Scalars['Long']['output'];
};

export type AccountBillingUsageStatsOrderBySpec = {
  column: AccountBillingUsageStatsColumn;
  direction: Ordering;
};

export type AccountBillingUsageStatsRecord = {
  __typename?: 'AccountBillingUsageStatsRecord';
  /** Dimensions of AccountBillingUsageStats that can be grouped by. */
  groupBy: AccountBillingUsageStatsDimensions;
  /** Metrics of AccountBillingUsageStats that can be aggregated over. */
  metrics: AccountBillingUsageStatsMetrics;
  /** Starting segment timestamp. */
  timestamp: Scalars['Timestamp']['output'];
};

export type AccountCapabilities = {
  __typename?: 'AccountCapabilities';
  clientVersions: Scalars['Boolean']['output'];
  clients: Scalars['Boolean']['output'];
  cloudGraphs: Scalars['Boolean']['output'];
  connectorsInRouter: Scalars['Boolean']['output'];
  contracts: Scalars['Boolean']['output'];
  customSessionLengths: Scalars['Boolean']['output'];
  datadog: Scalars['Boolean']['output'];
  federation: Scalars['Boolean']['output'];
  launches: Scalars['Boolean']['output'];
  linting: Scalars['Boolean']['output'];
  metrics: Scalars['Boolean']['output'];
  notifications: Scalars['Boolean']['output'];
  operationRegistry: Scalars['Boolean']['output'];
  persistedQueries: Scalars['Boolean']['output'];
  proposals: Scalars['Boolean']['output'];
  schemaValidation: Scalars['Boolean']['output'];
  sso: Scalars['Boolean']['output'];
  traces: Scalars['Boolean']['output'];
  userRoles: Scalars['Boolean']['output'];
  webhooks: Scalars['Boolean']['output'];
};

/** Columns of AccountCardinalityStats. */
export enum AccountCardinalityStatsColumn {
  CLIENT_NAME_CARDINALITY = 'CLIENT_NAME_CARDINALITY',
  CLIENT_VERSION_CARDINALITY = 'CLIENT_VERSION_CARDINALITY',
  OPERATION_SHAPE_CARDINALITY = 'OPERATION_SHAPE_CARDINALITY',
  SCHEMA_COORDINATE_CARDINALITY = 'SCHEMA_COORDINATE_CARDINALITY',
  SCHEMA_TAG = 'SCHEMA_TAG',
  SERVICE_ID = 'SERVICE_ID',
  TIMESTAMP = 'TIMESTAMP'
}

export type AccountCardinalityStatsDimensions = {
  __typename?: 'AccountCardinalityStatsDimensions';
  schemaTag?: Maybe<Scalars['String']['output']>;
  serviceId?: Maybe<Scalars['ID']['output']>;
};

/** Filter for data in AccountCardinalityStats. Fields with dimension names represent equality checks. All fields are implicitly ANDed together. */
export type AccountCardinalityStatsFilter = {
  and?: InputMaybe<Array<AccountCardinalityStatsFilter>>;
  in?: InputMaybe<AccountCardinalityStatsFilterIn>;
  not?: InputMaybe<AccountCardinalityStatsFilter>;
  or?: InputMaybe<Array<AccountCardinalityStatsFilter>>;
  /** Selects rows whose schemaTag dimension equals the given value if not null. To query for the null value, use {in: {schemaTag: [null]}} instead. */
  schemaTag?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose serviceId dimension equals the given value if not null. To query for the null value, use {in: {serviceId: [null]}} instead. */
  serviceId?: InputMaybe<Scalars['ID']['input']>;
};

/** Filter for data in AccountCardinalityStats. Fields match if the corresponding dimension's value is in the given list. All fields are implicitly ANDed together. */
export type AccountCardinalityStatsFilterIn = {
  /** Selects rows whose schemaTag dimension is in the given list. A null value in the list means a row with null for that dimension. */
  schemaTag?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose serviceId dimension is in the given list. A null value in the list means a row with null for that dimension. */
  serviceId?: InputMaybe<Array<InputMaybe<Scalars['ID']['input']>>>;
};

export type AccountCardinalityStatsMetrics = {
  __typename?: 'AccountCardinalityStatsMetrics';
  clientNameCardinality: Scalars['Float']['output'];
  clientVersionCardinality: Scalars['Float']['output'];
  operationShapeCardinality: Scalars['Float']['output'];
  schemaCoordinateCardinality: Scalars['Float']['output'];
};

export type AccountCardinalityStatsOrderBySpec = {
  column: AccountCardinalityStatsColumn;
  direction: Ordering;
};

export type AccountCardinalityStatsRecord = {
  __typename?: 'AccountCardinalityStatsRecord';
  /** Dimensions of AccountCardinalityStats that can be grouped by. */
  groupBy: AccountCardinalityStatsDimensions;
  /** Metrics of AccountCardinalityStats that can be aggregated over. */
  metrics: AccountCardinalityStatsMetrics;
  /** Starting segment timestamp. */
  timestamp: Scalars['Timestamp']['output'];
};

export type AccountChecksStatsMetrics = {
  __typename?: 'AccountChecksStatsMetrics';
  totalFailedChecks: Scalars['Long']['output'];
  totalSuccessfulChecks: Scalars['Long']['output'];
};

export type AccountChecksStatsRecord = {
  __typename?: 'AccountChecksStatsRecord';
  id: Scalars['ID']['output'];
  metrics: AccountChecksStatsMetrics;
  timestamp: Scalars['Timestamp']['output'];
};

/** Columns of AccountCoordinateUsage. */
export enum AccountCoordinateUsageColumn {
  CLIENT_NAME = 'CLIENT_NAME',
  CLIENT_VERSION = 'CLIENT_VERSION',
  ESTIMATED_EXECUTION_COUNT = 'ESTIMATED_EXECUTION_COUNT',
  EXECUTION_COUNT = 'EXECUTION_COUNT',
  KIND = 'KIND',
  NAMED_ATTRIBUTE = 'NAMED_ATTRIBUTE',
  NAMED_TYPE = 'NAMED_TYPE',
  OPERATION_SUBTYPE = 'OPERATION_SUBTYPE',
  OPERATION_TYPE = 'OPERATION_TYPE',
  QUERY_ID = 'QUERY_ID',
  QUERY_NAME = 'QUERY_NAME',
  REFERENCING_OPERATION_COUNT = 'REFERENCING_OPERATION_COUNT',
  REQUEST_COUNT_NULL = 'REQUEST_COUNT_NULL',
  REQUEST_COUNT_UNDEFINED = 'REQUEST_COUNT_UNDEFINED',
  SCHEMA_TAG = 'SCHEMA_TAG',
  SERVICE_ID = 'SERVICE_ID',
  TIMESTAMP = 'TIMESTAMP'
}

export type AccountCoordinateUsageDimensions = {
  __typename?: 'AccountCoordinateUsageDimensions';
  clientName?: Maybe<Scalars['String']['output']>;
  clientVersion?: Maybe<Scalars['String']['output']>;
  kind?: Maybe<Scalars['String']['output']>;
  namedAttribute?: Maybe<Scalars['String']['output']>;
  namedType?: Maybe<Scalars['String']['output']>;
  operationSubtype?: Maybe<Scalars['String']['output']>;
  operationType?: Maybe<Scalars['String']['output']>;
  queryId?: Maybe<Scalars['String']['output']>;
  queryName?: Maybe<Scalars['String']['output']>;
  schemaTag?: Maybe<Scalars['String']['output']>;
  serviceId?: Maybe<Scalars['ID']['output']>;
};

/** Filter for data in AccountCoordinateUsage. Fields with dimension names represent equality checks. All fields are implicitly ANDed together. */
export type AccountCoordinateUsageFilter = {
  and?: InputMaybe<Array<AccountCoordinateUsageFilter>>;
  /** Selects rows whose clientName dimension equals the given value if not null. To query for the null value, use {in: {clientName: [null]}} instead. */
  clientName?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose clientVersion dimension equals the given value if not null. To query for the null value, use {in: {clientVersion: [null]}} instead. */
  clientVersion?: InputMaybe<Scalars['String']['input']>;
  in?: InputMaybe<AccountCoordinateUsageFilterIn>;
  /** Selects rows whose kind dimension equals the given value if not null. To query for the null value, use {in: {kind: [null]}} instead. */
  kind?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose namedAttribute dimension equals the given value if not null. To query for the null value, use {in: {namedAttribute: [null]}} instead. */
  namedAttribute?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose namedType dimension equals the given value if not null. To query for the null value, use {in: {namedType: [null]}} instead. */
  namedType?: InputMaybe<Scalars['String']['input']>;
  not?: InputMaybe<AccountCoordinateUsageFilter>;
  /** Selects rows whose operationSubtype dimension equals the given value if not null. To query for the null value, use {in: {operationSubtype: [null]}} instead. */
  operationSubtype?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose operationType dimension equals the given value if not null. To query for the null value, use {in: {operationType: [null]}} instead. */
  operationType?: InputMaybe<Scalars['String']['input']>;
  or?: InputMaybe<Array<AccountCoordinateUsageFilter>>;
  /** Selects rows whose queryId dimension equals the given value if not null. To query for the null value, use {in: {queryId: [null]}} instead. */
  queryId?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose queryName dimension equals the given value if not null. To query for the null value, use {in: {queryName: [null]}} instead. */
  queryName?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose schemaTag dimension equals the given value if not null. To query for the null value, use {in: {schemaTag: [null]}} instead. */
  schemaTag?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose serviceId dimension equals the given value if not null. To query for the null value, use {in: {serviceId: [null]}} instead. */
  serviceId?: InputMaybe<Scalars['ID']['input']>;
};

/** Filter for data in AccountCoordinateUsage. Fields match if the corresponding dimension's value is in the given list. All fields are implicitly ANDed together. */
export type AccountCoordinateUsageFilterIn = {
  /** Selects rows whose clientName dimension is in the given list. A null value in the list means a row with null for that dimension. */
  clientName?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose clientVersion dimension is in the given list. A null value in the list means a row with null for that dimension. */
  clientVersion?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose kind dimension is in the given list. A null value in the list means a row with null for that dimension. */
  kind?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose namedAttribute dimension is in the given list. A null value in the list means a row with null for that dimension. */
  namedAttribute?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose namedType dimension is in the given list. A null value in the list means a row with null for that dimension. */
  namedType?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose operationSubtype dimension is in the given list. A null value in the list means a row with null for that dimension. */
  operationSubtype?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose operationType dimension is in the given list. A null value in the list means a row with null for that dimension. */
  operationType?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose queryId dimension is in the given list. A null value in the list means a row with null for that dimension. */
  queryId?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose queryName dimension is in the given list. A null value in the list means a row with null for that dimension. */
  queryName?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose schemaTag dimension is in the given list. A null value in the list means a row with null for that dimension. */
  schemaTag?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose serviceId dimension is in the given list. A null value in the list means a row with null for that dimension. */
  serviceId?: InputMaybe<Array<InputMaybe<Scalars['ID']['input']>>>;
};

export type AccountCoordinateUsageMetrics = {
  __typename?: 'AccountCoordinateUsageMetrics';
  estimatedExecutionCount: Scalars['Long']['output'];
  executionCount: Scalars['Long']['output'];
  referencingOperationCount: Scalars['Long']['output'];
  requestCountNull: Scalars['Long']['output'];
  requestCountUndefined: Scalars['Long']['output'];
};

export type AccountCoordinateUsageOrderBySpec = {
  column: AccountCoordinateUsageColumn;
  direction: Ordering;
};

export type AccountCoordinateUsageRecord = {
  __typename?: 'AccountCoordinateUsageRecord';
  /** Dimensions of AccountCoordinateUsage that can be grouped by. */
  groupBy: AccountCoordinateUsageDimensions;
  /** Metrics of AccountCoordinateUsage that can be aggregated over. */
  metrics: AccountCoordinateUsageMetrics;
  /** Starting segment timestamp. */
  timestamp: Scalars['Timestamp']['output'];
};

/** Columns of AccountEdgeServerInfos. */
export enum AccountEdgeServerInfosColumn {
  BOOT_ID = 'BOOT_ID',
  EXECUTABLE_SCHEMA_ID = 'EXECUTABLE_SCHEMA_ID',
  LIBRARY_VERSION = 'LIBRARY_VERSION',
  PLATFORM = 'PLATFORM',
  RUNTIME_VERSION = 'RUNTIME_VERSION',
  SCHEMA_TAG = 'SCHEMA_TAG',
  SERVER_ID = 'SERVER_ID',
  SERVICE_ID = 'SERVICE_ID',
  TIMESTAMP = 'TIMESTAMP',
  USER_VERSION = 'USER_VERSION'
}

export type AccountEdgeServerInfosDimensions = {
  __typename?: 'AccountEdgeServerInfosDimensions';
  bootId?: Maybe<Scalars['ID']['output']>;
  executableSchemaId?: Maybe<Scalars['ID']['output']>;
  libraryVersion?: Maybe<Scalars['String']['output']>;
  platform?: Maybe<Scalars['String']['output']>;
  runtimeVersion?: Maybe<Scalars['String']['output']>;
  schemaTag?: Maybe<Scalars['String']['output']>;
  serverId?: Maybe<Scalars['ID']['output']>;
  serviceId?: Maybe<Scalars['ID']['output']>;
  userVersion?: Maybe<Scalars['String']['output']>;
};

/** Filter for data in AccountEdgeServerInfos. Fields with dimension names represent equality checks. All fields are implicitly ANDed together. */
export type AccountEdgeServerInfosFilter = {
  and?: InputMaybe<Array<AccountEdgeServerInfosFilter>>;
  /** Selects rows whose bootId dimension equals the given value if not null. To query for the null value, use {in: {bootId: [null]}} instead. */
  bootId?: InputMaybe<Scalars['ID']['input']>;
  /** Selects rows whose executableSchemaId dimension equals the given value if not null. To query for the null value, use {in: {executableSchemaId: [null]}} instead. */
  executableSchemaId?: InputMaybe<Scalars['ID']['input']>;
  in?: InputMaybe<AccountEdgeServerInfosFilterIn>;
  /** Selects rows whose libraryVersion dimension equals the given value if not null. To query for the null value, use {in: {libraryVersion: [null]}} instead. */
  libraryVersion?: InputMaybe<Scalars['String']['input']>;
  not?: InputMaybe<AccountEdgeServerInfosFilter>;
  or?: InputMaybe<Array<AccountEdgeServerInfosFilter>>;
  /** Selects rows whose platform dimension equals the given value if not null. To query for the null value, use {in: {platform: [null]}} instead. */
  platform?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose runtimeVersion dimension equals the given value if not null. To query for the null value, use {in: {runtimeVersion: [null]}} instead. */
  runtimeVersion?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose schemaTag dimension equals the given value if not null. To query for the null value, use {in: {schemaTag: [null]}} instead. */
  schemaTag?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose serverId dimension equals the given value if not null. To query for the null value, use {in: {serverId: [null]}} instead. */
  serverId?: InputMaybe<Scalars['ID']['input']>;
  /** Selects rows whose serviceId dimension equals the given value if not null. To query for the null value, use {in: {serviceId: [null]}} instead. */
  serviceId?: InputMaybe<Scalars['ID']['input']>;
  /** Selects rows whose userVersion dimension equals the given value if not null. To query for the null value, use {in: {userVersion: [null]}} instead. */
  userVersion?: InputMaybe<Scalars['String']['input']>;
};

/** Filter for data in AccountEdgeServerInfos. Fields match if the corresponding dimension's value is in the given list. All fields are implicitly ANDed together. */
export type AccountEdgeServerInfosFilterIn = {
  /** Selects rows whose bootId dimension is in the given list. A null value in the list means a row with null for that dimension. */
  bootId?: InputMaybe<Array<InputMaybe<Scalars['ID']['input']>>>;
  /** Selects rows whose executableSchemaId dimension is in the given list. A null value in the list means a row with null for that dimension. */
  executableSchemaId?: InputMaybe<Array<InputMaybe<Scalars['ID']['input']>>>;
  /** Selects rows whose libraryVersion dimension is in the given list. A null value in the list means a row with null for that dimension. */
  libraryVersion?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose platform dimension is in the given list. A null value in the list means a row with null for that dimension. */
  platform?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose runtimeVersion dimension is in the given list. A null value in the list means a row with null for that dimension. */
  runtimeVersion?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose schemaTag dimension is in the given list. A null value in the list means a row with null for that dimension. */
  schemaTag?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose serverId dimension is in the given list. A null value in the list means a row with null for that dimension. */
  serverId?: InputMaybe<Array<InputMaybe<Scalars['ID']['input']>>>;
  /** Selects rows whose serviceId dimension is in the given list. A null value in the list means a row with null for that dimension. */
  serviceId?: InputMaybe<Array<InputMaybe<Scalars['ID']['input']>>>;
  /** Selects rows whose userVersion dimension is in the given list. A null value in the list means a row with null for that dimension. */
  userVersion?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
};

export type AccountEdgeServerInfosOrderBySpec = {
  column: AccountEdgeServerInfosColumn;
  direction: Ordering;
};

export type AccountEdgeServerInfosRecord = {
  __typename?: 'AccountEdgeServerInfosRecord';
  /** Dimensions of AccountEdgeServerInfos that can be grouped by. */
  groupBy: AccountEdgeServerInfosDimensions;
  /** Starting segment timestamp. */
  timestamp: Scalars['Timestamp']['output'];
};

/** Columns of AccountErrorStats. */
export enum AccountErrorStatsColumn {
  CLIENT_NAME = 'CLIENT_NAME',
  CLIENT_VERSION = 'CLIENT_VERSION',
  ERRORS_COUNT = 'ERRORS_COUNT',
  PATH = 'PATH',
  QUERY_ID = 'QUERY_ID',
  QUERY_NAME = 'QUERY_NAME',
  REQUESTS_WITH_ERRORS_COUNT = 'REQUESTS_WITH_ERRORS_COUNT',
  SCHEMA_HASH = 'SCHEMA_HASH',
  SCHEMA_TAG = 'SCHEMA_TAG',
  SERVICE_ID = 'SERVICE_ID',
  TIMESTAMP = 'TIMESTAMP'
}

export type AccountErrorStatsDimensions = {
  __typename?: 'AccountErrorStatsDimensions';
  clientName?: Maybe<Scalars['String']['output']>;
  clientVersion?: Maybe<Scalars['String']['output']>;
  path?: Maybe<Scalars['String']['output']>;
  queryId?: Maybe<Scalars['ID']['output']>;
  queryName?: Maybe<Scalars['String']['output']>;
  schemaHash?: Maybe<Scalars['String']['output']>;
  schemaTag?: Maybe<Scalars['String']['output']>;
  serviceId?: Maybe<Scalars['ID']['output']>;
};

/** Filter for data in AccountErrorStats. Fields with dimension names represent equality checks. All fields are implicitly ANDed together. */
export type AccountErrorStatsFilter = {
  and?: InputMaybe<Array<AccountErrorStatsFilter>>;
  /** Selects rows whose clientName dimension equals the given value if not null. To query for the null value, use {in: {clientName: [null]}} instead. */
  clientName?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose clientVersion dimension equals the given value if not null. To query for the null value, use {in: {clientVersion: [null]}} instead. */
  clientVersion?: InputMaybe<Scalars['String']['input']>;
  in?: InputMaybe<AccountErrorStatsFilterIn>;
  not?: InputMaybe<AccountErrorStatsFilter>;
  or?: InputMaybe<Array<AccountErrorStatsFilter>>;
  /** Selects rows whose path dimension equals the given value if not null. To query for the null value, use {in: {path: [null]}} instead. */
  path?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose queryId dimension equals the given value if not null. To query for the null value, use {in: {queryId: [null]}} instead. */
  queryId?: InputMaybe<Scalars['ID']['input']>;
  /** Selects rows whose queryName dimension equals the given value if not null. To query for the null value, use {in: {queryName: [null]}} instead. */
  queryName?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose schemaHash dimension equals the given value if not null. To query for the null value, use {in: {schemaHash: [null]}} instead. */
  schemaHash?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose schemaTag dimension equals the given value if not null. To query for the null value, use {in: {schemaTag: [null]}} instead. */
  schemaTag?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose serviceId dimension equals the given value if not null. To query for the null value, use {in: {serviceId: [null]}} instead. */
  serviceId?: InputMaybe<Scalars['ID']['input']>;
};

/** Filter for data in AccountErrorStats. Fields match if the corresponding dimension's value is in the given list. All fields are implicitly ANDed together. */
export type AccountErrorStatsFilterIn = {
  /** Selects rows whose clientName dimension is in the given list. A null value in the list means a row with null for that dimension. */
  clientName?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose clientVersion dimension is in the given list. A null value in the list means a row with null for that dimension. */
  clientVersion?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose path dimension is in the given list. A null value in the list means a row with null for that dimension. */
  path?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose queryId dimension is in the given list. A null value in the list means a row with null for that dimension. */
  queryId?: InputMaybe<Array<InputMaybe<Scalars['ID']['input']>>>;
  /** Selects rows whose queryName dimension is in the given list. A null value in the list means a row with null for that dimension. */
  queryName?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose schemaHash dimension is in the given list. A null value in the list means a row with null for that dimension. */
  schemaHash?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose schemaTag dimension is in the given list. A null value in the list means a row with null for that dimension. */
  schemaTag?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose serviceId dimension is in the given list. A null value in the list means a row with null for that dimension. */
  serviceId?: InputMaybe<Array<InputMaybe<Scalars['ID']['input']>>>;
};

export type AccountErrorStatsMetrics = {
  __typename?: 'AccountErrorStatsMetrics';
  errorsCount: Scalars['Long']['output'];
  requestsWithErrorsCount: Scalars['Long']['output'];
};

export type AccountErrorStatsOrderBySpec = {
  column: AccountErrorStatsColumn;
  direction: Ordering;
};

export type AccountErrorStatsRecord = {
  __typename?: 'AccountErrorStatsRecord';
  /** Dimensions of AccountErrorStats that can be grouped by. */
  groupBy: AccountErrorStatsDimensions;
  /** Metrics of AccountErrorStats that can be aggregated over. */
  metrics: AccountErrorStatsMetrics;
  /** Starting segment timestamp. */
  timestamp: Scalars['Timestamp']['output'];
};

/** Columns of AccountFederatedErrorStats. */
export enum AccountFederatedErrorStatsColumn {
  AGENT_VERSION = 'AGENT_VERSION',
  CLIENT_NAME = 'CLIENT_NAME',
  CLIENT_VERSION = 'CLIENT_VERSION',
  ERROR_CODE = 'ERROR_CODE',
  ERROR_COUNT = 'ERROR_COUNT',
  ERROR_PATH = 'ERROR_PATH',
  ERROR_SERVICE = 'ERROR_SERVICE',
  OPERATION_ID = 'OPERATION_ID',
  OPERATION_NAME = 'OPERATION_NAME',
  OPERATION_TYPE = 'OPERATION_TYPE',
  SCHEMA_TAG = 'SCHEMA_TAG',
  SERVICE_ID = 'SERVICE_ID',
  SEVERITY = 'SEVERITY',
  TIMESTAMP = 'TIMESTAMP'
}

export type AccountFederatedErrorStatsDimensions = {
  __typename?: 'AccountFederatedErrorStatsDimensions';
  agentVersion?: Maybe<Scalars['String']['output']>;
  clientName?: Maybe<Scalars['String']['output']>;
  clientVersion?: Maybe<Scalars['String']['output']>;
  errorCode?: Maybe<Scalars['String']['output']>;
  errorPath?: Maybe<Scalars['String']['output']>;
  errorService?: Maybe<Scalars['String']['output']>;
  operationId?: Maybe<Scalars['String']['output']>;
  operationName?: Maybe<Scalars['String']['output']>;
  operationType?: Maybe<Scalars['String']['output']>;
  schemaTag?: Maybe<Scalars['String']['output']>;
  serviceId?: Maybe<Scalars['ID']['output']>;
  severity?: Maybe<Scalars['String']['output']>;
};

/** Filter for data in AccountFederatedErrorStats. Fields with dimension names represent equality checks. All fields are implicitly ANDed together. */
export type AccountFederatedErrorStatsFilter = {
  /** Selects rows whose agentVersion dimension equals the given value if not null. To query for the null value, use {in: {agentVersion: [null]}} instead. */
  agentVersion?: InputMaybe<Scalars['String']['input']>;
  and?: InputMaybe<Array<AccountFederatedErrorStatsFilter>>;
  /** Selects rows whose clientName dimension equals the given value if not null. To query for the null value, use {in: {clientName: [null]}} instead. */
  clientName?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose clientVersion dimension equals the given value if not null. To query for the null value, use {in: {clientVersion: [null]}} instead. */
  clientVersion?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose errorCode dimension equals the given value if not null. To query for the null value, use {in: {errorCode: [null]}} instead. */
  errorCode?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose errorPath dimension equals the given value if not null. To query for the null value, use {in: {errorPath: [null]}} instead. */
  errorPath?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose errorService dimension equals the given value if not null. To query for the null value, use {in: {errorService: [null]}} instead. */
  errorService?: InputMaybe<Scalars['String']['input']>;
  in?: InputMaybe<AccountFederatedErrorStatsFilterIn>;
  not?: InputMaybe<AccountFederatedErrorStatsFilter>;
  /** Selects rows whose operationId dimension equals the given value if not null. To query for the null value, use {in: {operationId: [null]}} instead. */
  operationId?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose operationName dimension equals the given value if not null. To query for the null value, use {in: {operationName: [null]}} instead. */
  operationName?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose operationType dimension equals the given value if not null. To query for the null value, use {in: {operationType: [null]}} instead. */
  operationType?: InputMaybe<Scalars['String']['input']>;
  or?: InputMaybe<Array<AccountFederatedErrorStatsFilter>>;
  /** Selects rows whose schemaTag dimension equals the given value if not null. To query for the null value, use {in: {schemaTag: [null]}} instead. */
  schemaTag?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose serviceId dimension equals the given value if not null. To query for the null value, use {in: {serviceId: [null]}} instead. */
  serviceId?: InputMaybe<Scalars['ID']['input']>;
  /** Selects rows whose severity dimension equals the given value if not null. To query for the null value, use {in: {severity: [null]}} instead. */
  severity?: InputMaybe<Scalars['String']['input']>;
};

/** Filter for data in AccountFederatedErrorStats. Fields match if the corresponding dimension's value is in the given list. All fields are implicitly ANDed together. */
export type AccountFederatedErrorStatsFilterIn = {
  /** Selects rows whose agentVersion dimension is in the given list. A null value in the list means a row with null for that dimension. */
  agentVersion?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose clientName dimension is in the given list. A null value in the list means a row with null for that dimension. */
  clientName?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose clientVersion dimension is in the given list. A null value in the list means a row with null for that dimension. */
  clientVersion?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose errorCode dimension is in the given list. A null value in the list means a row with null for that dimension. */
  errorCode?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose errorPath dimension is in the given list. A null value in the list means a row with null for that dimension. */
  errorPath?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose errorService dimension is in the given list. A null value in the list means a row with null for that dimension. */
  errorService?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose operationId dimension is in the given list. A null value in the list means a row with null for that dimension. */
  operationId?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose operationName dimension is in the given list. A null value in the list means a row with null for that dimension. */
  operationName?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose operationType dimension is in the given list. A null value in the list means a row with null for that dimension. */
  operationType?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose schemaTag dimension is in the given list. A null value in the list means a row with null for that dimension. */
  schemaTag?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  /** Selects rows whose serviceId dimension is in the given list. A null value in the list means a row with null for that dimension. */
  serviceId?: InputMaybe<Array<InputMaybe<Scalars['ID']['input']>>>;
  /** Selects rows whose severity dimension is in the given list. A null value in the list means a row with null for that dimension. */
  severity?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
};

export type AccountFederatedErrorStatsMetrics = {
  __typename?: 'AccountFederatedErrorStatsMetrics';
  errorCount: Scalars['Long']['output'];
};

export type AccountFederatedErrorStatsOrderBySpec = {
  column: AccountFederatedErrorStatsColumn;
  direction: Ordering;
};

export type AccountFederatedErrorStatsRecord = {
  __typename?: 'AccountFederatedErrorStatsRecord';
  /** Dimensions of AccountFederatedErrorStats that can be grouped by. */
  groupBy: AccountFederatedErrorStatsDimensions;
  /** Metrics of AccountFederatedErrorStats that can be aggregated over. */
  metrics: AccountFederatedErrorStatsMetrics;
  /** Starting segment timestamp. */
  timestamp: Scalars['Timestamp']['output'];
};

/** Columns of AccountFieldExecutions. */
export enum AccountFieldExecutionsColumn {
  ERRORS_COUNT = 'ERRORS_COUNT',
  ESTIMATED_EXECUTION_COUNT = 'ESTIMATED_EXECUTION_COUNT',
  FIELD_NAME = 'FIELD_NAME',
  OBSERVED_EXECUTION_COUNT = 'OBSERVED_EXECUTION_COUNT',
  PARENT_TYPE = 'PARENT_TYPE',
  REFERENCING_OPERATION_COUNT = 'REFERENCING_OPERATION_COUNT',
  REQUESTS_WITH_ERRORS_COUNT = 'REQUESTS_WITH_ERRORS_COUNT',
  SCHEMA_TAG = 'SCHEMA_TAG',
  SERVICE_ID = 'SERVICE_ID',
  TIMESTAMP = 'TIMESTAMP'
}

export type AccountFieldExecutionsDimensions = {
  __typename?: 'AccountFieldExecutionsDimensions';
  fieldName?: Maybe<Scalars['String']['output']>;
  parentType?: Maybe<Scalars['String']['output']>;
  schemaTag?: Maybe<Scalars['String']['output']>;
  serviceId?: Maybe<Scalars['ID']['output']>;
};

/** Filter for data in AccountFieldExecutions. Fields with dimension names represent equality checks. All fields are implicitly ANDed together. */
export type AccountFieldExecutionsFilter = {
  and?: InputMaybe<Array<AccountFieldExecutionsFilter>>;
  /** Selects rows whose fieldName dimension equals the given value if not null. To query for the null value, use {in: {fieldName: [null]}} instead. */
  fieldName?: InputMaybe<Scalars['String']['input']>;
  in?: InputMaybe<AccountFieldExecutionsFilterIn>;
  not?: InputMaybe<AccountFieldExecutionsFilter>;
  or?: InputMaybe<Array<AccountFieldExecutionsFilter>>;
  /** Selects rows whose parentType dimension equals the given value if not null. To query for the null value, use {in: {parentType: [null]}} instead. */
  parentType?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose schemaTag dimension equals the given value if not null. To query for the null value, use {in: {schemaTag: [null]}} instead. */
  schemaTag?: InputMaybe<Scalars['String']['input']>;
  /** Selects rows whose serviceId dimension equals the given value if not null. To query for the null value, use {in: {serviceId: [