import type { Schema } from '../sdk.gen.js';
import type { ExecutionResult } from 'graphql';
export type Maybe<T> = T | undefined;
export type InputMaybe<T> = T | undefined;
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;
    };
    AccessToken: {
        input: string;
        output: string;
    };
    Annotation: {
        input: Schema<'Annotation'>;
        output: Schema<'Annotation'>;
    };
    AttemptLimit: {
        input: number;
        output: number;
    };
    AttemptOperation: {
        input: Schema<'AttemptOperation'>;
        output: Schema<'AttemptOperation'>;
    };
    AttemptTier: {
        input: Schema<'AttemptTier'>;
        output: Schema<'AttemptTier'>;
    };
    AuthorizationName: {
        input: string;
        output: string;
    };
    CreditChargeLimit: {
        input: number;
        output: number;
    };
    CreditGrantLimit: {
        input: number;
        output: number;
    };
    Cursor: {
        input: string;
        output: string;
    };
    DateTime: {
        input: string;
        output: string;
    };
    Definition: {
        input: Schema<'Definition'>;
        output: Schema<'Definition'>;
    };
    Description: {
        input: string;
        output: string;
    };
    DisplayName: {
        input: string;
        output: string;
    };
    ErrorStatus: {
        input: string;
        output: string;
    };
    ExtendedFloat: {
        input: Schema<'ExtendedFloat'>;
        output: Schema<'ExtendedFloat'>;
    };
    Failure: {
        input: Schema<'Failure'>;
        output: Schema<'Failure'>;
    };
    FormulationName: {
        input: string;
        output: string;
    };
    KeyItem: {
        input: Schema<'KeyItem'>;
        output: Schema<'KeyItem'>;
    };
    Label: {
        input: string;
        output: string;
    };
    Limit: {
        input: number;
        output: number;
    };
    Outline: {
        input: Schema<'Outline'>;
        output: Schema<'Outline'>;
    };
    ProblemSize: {
        input: Schema<'ProblemSize'>;
        output: Schema<'ProblemSize'>;
    };
    ProblemSummary: {
        input: Schema<'ProblemSummary'>;
        output: Schema<'ProblemSummary'>;
    };
    Slug: {
        input: string;
        output: string;
    };
    SolutionSummary: {
        input: Schema<'SolutionSummary'>;
        output: Schema<'SolutionSummary'>;
    };
    SolveNotificationLimit: {
        input: number;
        output: number;
    };
    SolveOptions: {
        input: Schema<'SolveOptions'>;
        output: Schema<'SolveOptions'>;
    };
    SolveOutcome: {
        input: Schema<'SolveOutcome'>;
        output: Schema<'SolveOutcome'>;
    };
    SolveStrategy: {
        input: Schema<'SolveStrategy'>;
        output: Schema<'SolveStrategy'>;
    };
    Source: {
        input: string;
        output: string;
    };
    TagName: {
        input: string;
        output: string;
    };
    Transformation: {
        input: Schema<'Transformation'>;
        output: Schema<'Transformation'>;
    };
    Uuid: {
        input: string;
        output: string;
    };
};
export type Account = Node & {
    readonly __typename?: 'Account';
    readonly id: Scalars['ID']['output'];
};
export type Attempt = Node & {
    readonly __typename?: 'Attempt';
    /** Key-value metadata associated with this attempt */
    readonly annotations: ReadonlyArray<Scalars['Annotation']['output']>;
    /** Credit cost, this amount may change until the attempt has ended */
    readonly chargeAmount: Scalars['Int']['output'];
    /** Additional information about the attempt, if applicable */
    readonly content?: Maybe<AttemptContent>;
    /**
     * The time at which the attempt completed (successfully or not). Null if the
     * attempt is still pending.
     */
    readonly endedAt?: Maybe<Scalars['DateTime']['output']>;
    /** Status of the attempt's failure, if applicable */
    readonly errorStatus?: Maybe<Scalars['ErrorStatus']['output']>;
    readonly id: Scalars['ID']['output'];
    /** The attempt's metadata */
    readonly operation: Scalars['AttemptOperation']['output'];
    /** The underlying problem's size */
    readonly problemSize: Scalars['ProblemSize']['output'];
    /** The time the attempt was started */
    readonly startedAt: Scalars['DateTime']['output'];
    /** This tier may be adjusted after reification */
    readonly tier: Scalars['AttemptTier']['output'];
};
export type AttemptConnection = {
    readonly __typename?: 'AttemptConnection';
    readonly edges: ReadonlyArray<AttemptEdge>;
    readonly pageInfo: PageInfo;
    readonly totalCount: Scalars['Int']['output'];
};
export type AttemptContent = QueuedSolve;
export type AttemptEdge = {
    readonly __typename?: 'AttemptEdge';
    readonly cursor: Scalars['Cursor']['output'];
    readonly node: Attempt;
};
export type AttemptFilter = {
    readonly annotations?: InputMaybe<ReadonlyArray<Scalars['Annotation']['input']>>;
    readonly operation?: InputMaybe<Scalars['AttemptOperation']['input']>;
};
/** Authorization for programmatic API access */
export type Authorization = Node & {
    readonly __typename?: 'Authorization';
    readonly createdAt: Scalars['DateTime']['output'];
    readonly expiresAt: Scalars['DateTime']['output'];
    readonly id: Scalars['ID']['output'];
    readonly lastUsedAt?: Maybe<Scalars['DateTime']['output']>;
    readonly member: Member;
    readonly name: Scalars['AuthorizationName']['output'];
    readonly tokenSuffix: Scalars['String']['output'];
};
export type CreditCharge = Node & {
    readonly __typename?: 'CreditCharge';
    readonly amount: Scalars['Int']['output'];
    readonly createdAt: Scalars['DateTime']['output'];
    readonly id: Scalars['ID']['output'];
    readonly product: Product;
};
export type CreditChargeConnection = {
    readonly __typename?: 'CreditChargeConnection';
    readonly edges: ReadonlyArray<CreditChargeEdge>;
    readonly pageInfo: PageInfo;
    readonly totalCount: Scalars['Int']['output'];
};
export type CreditChargeEdge = {
    readonly __typename?: 'CreditChargeEdge';
    readonly cursor: Scalars['Cursor']['output'];
    readonly node: CreditCharge;
};
export type CreditGrant = Node & {
    readonly __typename?: 'CreditGrant';
    readonly amount: Scalars['Int']['output'];
    readonly createdAt: Scalars['DateTime']['output'];
    readonly id: Scalars['ID']['output'];
    readonly reason?: Maybe<Scalars['String']['output']>;
};
export type CreditGrantConnection = {
    readonly __typename?: 'CreditGrantConnection';
    readonly edges: ReadonlyArray<CreditGrantEdge>;
    readonly pageInfo: PageInfo;
    readonly totalCount: Scalars['Int']['output'];
};
export type CreditGrantEdge = {
    readonly __typename?: 'CreditGrantEdge';
    readonly cursor: Scalars['Cursor']['output'];
    readonly node: CreditGrant;
};
export type DeleteFormulationOutput = {
    readonly __typename?: 'DeleteFormulationOutput';
    readonly attemptCount: Scalars['Int']['output'];
    /**
     * not exist and guaranteed positive if it did.
     */
    readonly specificationCount: Scalars['Int']['output'];
};
export type Formulation = Node & {
    readonly __typename?: 'Formulation';
    /** Returns attempts for this formulation, sorted by start time */
    readonly attempts: AttemptConnection;
    readonly createdAt: Scalars['DateTime']['output'];
    /** The default tag to use when selecting a specification without an explicit tag */
    readonly defaultTagName: Scalars['TagName']['output'];
    /** A human-readable name for this specification */
    readonly displayName: Scalars['DisplayName']['output'];
    readonly id: Scalars['ID']['output'];
    /** Time at which the formulation's most recent specification was created */
    readonly lastSpecifiedAt: Scalars['DateTime']['output'];
    /** A unique name for this specification */
    readonly name: Scalars['FormulationName']['output'];
    /** Specification for a given revision number */
    readonly specification?: Maybe<Specification>;
    /** Specifications registered for this formulation, sorted by creation time */
    readonly specifications: SpecificationConnection;
    /**
     * Tag for a given name. If not specified, the formulation's default tag name is
     * used.
     */
    readonly tag?: Maybe<SpecificationTag>;
    /** Tags, sorted by update time by default */
    readonly tags: SpecificationTagConnection;
};
export type FormulationAttemptsArgs = {
    before?: InputMaybe<Scalars['Cursor']['input']>;
    filter?: InputMaybe<AttemptFilter>;
    last: Scalars['AttemptLimit']['input'];
};
export type FormulationSpecificationArgs = {
    revno: Scalars['Int']['input'];
};
export type FormulationSpecificationsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    first?: InputMaybe<Scalars['Limit']['input']>;
    last?: InputMaybe<Scalars['Limit']['input']>;
};
export type FormulationTagArgs = {
    name?: InputMaybe<Scalars['TagName']['input']>;
};
export type FormulationTagsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    filter?: InputMaybe<FormulationTagsFilter>;
    first?: InputMaybe<Scalars['Limit']['input']>;
    last?: InputMaybe<Scalars['Limit']['input']>;
    orderBy?: InputMaybe<FormulationTagsOrderBy>;
};
export type FormulationConnection = {
    readonly __typename?: 'FormulationConnection';
    readonly edges: ReadonlyArray<FormulationEdge>;
    readonly pageInfo: PageInfo;
    readonly totalCount: Scalars['Int']['output'];
};
export type FormulationEdge = {
    readonly __typename?: 'FormulationEdge';
    readonly cursor: Scalars['Cursor']['output'];
    readonly node: Formulation;
};
export type FormulationFilter = {
    readonly displayNameLike?: InputMaybe<Scalars['String']['input']>;
};
export type FormulationOrderBy = 'DISPLAY_NAME' | 'LAST_SPECIFIED_AT';
export type FormulationPatch = {
    readonly defaultTagName?: InputMaybe<Scalars['TagName']['input']>;
    readonly displayName?: InputMaybe<Scalars['DisplayName']['input']>;
};
export type FormulationTagsFilter = {
    /** Only return tags which are (resp. not) shared if set to true (resp. false) */
    readonly isShared?: InputMaybe<Scalars['Boolean']['input']>;
};
export type FormulationTagsOrderBy = 'LAST_UPDATED_AT' | 'NAME';
export type GenerateAuthorizationInput = {
    readonly name: Scalars['AuthorizationName']['input'];
    readonly ttlDays: Scalars['Int']['input'];
};
export type GeneratedAuthorization = {
    readonly __typename?: 'GeneratedAuthorization';
    readonly authorization: Authorization;
    readonly token: Scalars['AccessToken']['output'];
};
export type Member = Node & {
    readonly __typename?: 'Member';
    readonly activeSessions: ReadonlyArray<Session>;
    readonly authorizations: ReadonlyArray<Authorization>;
    readonly creditBalance: Scalars['Int']['output'];
    readonly creditCharges: CreditChargeConnection;
    readonly creditGrants: CreditGrantConnection;
    readonly email: Scalars['String']['output'];
    readonly emailVerifiedAt?: Maybe<Scalars['DateTime']['output']>;
    readonly id: Scalars['ID']['output'];
    readonly registeredAt: Scalars['DateTime']['output'];
};
export type MemberCreditChargesArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    first?: InputMaybe<Scalars['CreditChargeLimit']['input']>;
    last?: InputMaybe<Scalars['CreditChargeLimit']['input']>;
};
export type MemberCreditGrantsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    first?: InputMaybe<Scalars['CreditGrantLimit']['input']>;
    last?: InputMaybe<Scalars['CreditGrantLimit']['input']>;
};
export type Mutation = {
    readonly __typename?: 'Mutation';
    /**
     * Cancels a queued solve, throwing if the attempt does not exist, does not match
     * a queued solve attempt, or is not pending anymore. Returns true if the solve
     * had not been dequeued yet.
     */
    readonly cancelQueuedSolve: Scalars['Boolean']['output'];
    /**
     * Deletes any formulation matching the input name, along with all its associated
     * entities (queued solve attempts, specifications...).
     */
    readonly deleteFormulation: DeleteFormulationOutput;
    /** Generates a new access token to call the API */
    readonly generateAuthorization: GeneratedAuthorization;
    /**
     * Uploads a new specification to be used for solving problems. If no formulation
     * exists for the given name, one will be created automatically.
     */
    readonly registerSpecification: Specification;
    /** Revokes all currently active sessions and returns their count */
    readonly revokeActiveSessions: Scalars['Int']['output'];
    /** Revokes an authorization and its associated access token */
    readonly revokeAuthorization: Scalars['Boolean']['output'];
    /**
     * Adds a tag to a specification.  Any tags which already existed will be updated
     * to point to this specification. Note that standard tags can't be added here.
     */
    readonly tagSpecification: Specification;
    /** Updates an existing formulation's metadata */
    readonly updateFormulation: Formulation;
};
export type MutationCancelQueuedSolveArgs = {
    uuid: Scalars['Uuid']['input'];
};
export type MutationDeleteFormulationArgs = {
    name: Scalars['FormulationName']['input'];
};
export type MutationGenerateAuthorizationArgs = {
    input: GenerateAuthorizationInput;
};
export type MutationRegisterSpecificationArgs = {
    input: RegisterSpecificationInput;
};
export type MutationRevokeAuthorizationArgs = {
    input: RevokeAuthorizationInput;
};
export type MutationTagSpecificationArgs = {
    input: TagSpecificationInput;
};
export type MutationUpdateFormulationArgs = {
    input: UpdateFormulationInput;
};
export type Node = {
    readonly id: Scalars['ID']['output'];
};
export type PageInfo = {
    readonly __typename?: 'PageInfo';
    readonly endCursor: Scalars['Cursor']['output'];
    readonly hasNextPage: Scalars['Boolean']['output'];
    readonly hasPreviousPage: Scalars['Boolean']['output'];
    readonly startCursor: Scalars['Cursor']['output'];
};
export type PerformanceAttempt = {
    readonly __typename?: 'PerformanceAttempt';
    readonly operation: Scalars['String']['output'];
    readonly problemSize: Scalars['String']['output'];
};
export type Product = PerformanceAttempt;
export type Query = {
    readonly __typename?: 'Query';
    /** Returns attempts sorted by start time */
    readonly attempts: AttemptConnection;
    /** Fetches a formulation by name */
    readonly formulation?: Maybe<Formulation>;
    /**
     * Paginates formulations visible by the caller, sorted by display name unless
     * specified otherwise
     */
    readonly formulations: FormulationConnection;
    readonly me: Member;
    readonly node: Node;
    readonly queuedSolve?: Maybe<QueuedSolve>;
};
export type QueryAttemptsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    filter?: InputMaybe<AttemptFilter>;
    first?: InputMaybe<Scalars['AttemptLimit']['input']>;
    last?: InputMaybe<Scalars['AttemptLimit']['input']>;
};
export type QueryFormulationArgs = {
    name: Scalars['FormulationName']['input'];
};
export type QueryFormulationsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    filter?: InputMaybe<FormulationFilter>;
    first?: InputMaybe<Scalars['Limit']['input']>;
    last?: InputMaybe<Scalars['Limit']['input']>;
    orderBy?: InputMaybe<FormulationOrderBy>;
};
export type QueryNodeArgs = {
    id: Scalars['ID']['input'];
};
export type QueryQueuedSolveArgs = {
    uuid: Scalars['Uuid']['input'];
};
export type QueuedSolve = {
    readonly __typename?: 'QueuedSolve';
    /** The queued solve's parent attempt */
    readonly attempt: Attempt;
    /** The time the solve was dequeued */
    readonly dequeuedAt?: Maybe<Scalars['DateTime']['output']>;
    /**
     * Time after which this attempt becomes eligible for GC. At this point it will
     * not be queriable from the API.
     */
    readonly expiresAt: Scalars['DateTime']['output'];
    /** Solve failure information, if applicable */
    readonly failure?: Maybe<Scalars['Failure']['output']>;
    /** Progress notifications */
    readonly notifications: SolveNotificationConnection;
    readonly options: Scalars['SolveOptions']['output'];
    /** Solve outcome, null if the attempt is still pending */
    readonly outcome?: Maybe<Scalars['SolveOutcome']['output']>;
    /** Reification summary, available after the solve has been reified */
    readonly problemSummary?: Maybe<Scalars['ProblemSummary']['output']>;
    /** Solution summary, available after the solve has completed feasibly */
    readonly solutionSummary?: Maybe<Scalars['SolutionSummary']['output']>;
    /**
     * Original specification used to start the attempt. This specification does not
     * include any transformations requested in the attempt (e.g. relaxation).
     */
    readonly specification: Specification;
    /**
     * Tag used to select the specification when starting the attempt. This is useful
     * since the tag may have drifted since: the specification used may be different
     * from the one currently tagged as such.
     */
    readonly specificationTagName: Scalars['TagName']['output'];
    readonly strategy?: Maybe<Scalars['SolveStrategy']['output']>;
    /** Specification transformations */
    readonly transformations: ReadonlyArray<Scalars['Transformation']['output']>;
    /** Unique identifier for this solve */
    readonly uuid: Scalars['Uuid']['output'];
};
export type QueuedSolveNotificationsArgs = {
    before?: InputMaybe<Scalars['Cursor']['input']>;
    last: Scalars['SolveNotificationLimit']['input'];
};
export type RegisterSpecificationInput = {
    /** Information about the specification */
    readonly description?: InputMaybe<Scalars['Description']['input']>;
    /**
     * The name of the specification's underlying formulation. It will be created
     * automatically if it doesn't already exist. See also `newFormulationOptions`
     * below.
     */
    readonly formulationName: Scalars['FormulationName']['input'];
    /**
     * Patch applied when creating the specification's underlying formulation.
     * Setting this option will cause registration to fail if a formulation for the
     * given name already exists.
     *
     * If a default tag name is set in this patch, the corresponding tag will
     * automatically be added to the tag names specified above.
     */
    readonly newFormulationPatch?: InputMaybe<FormulationPatch>;
    /** The specification's sources */
    readonly sources: ReadonlyArray<Scalars['Source']['input']>;
    /**
     * Custom tags for the registered specification. This allows solving multiple
     * variants of a given model. The standard `latest` tag is always added
     * automatically. Any pre-existing tags will be updated to point to the new
     * specification.
     */
    readonly tagNames?: InputMaybe<ReadonlyArray<Scalars['TagName']['input']>>;
};
export type RevokeAuthorizationInput = {
    readonly name: Scalars['AuthorizationName']['input'];
};
/** Interactive sessions for browser access */
export type Session = Node & {
    readonly __typename?: 'Session';
    readonly createdAt: Scalars['DateTime']['output'];
    readonly expiresAt: Scalars['DateTime']['output'];
    readonly id: Scalars['ID']['output'];
    readonly member: Member;
};
/** QueueSolve progress notification */
export type SolveNotification = {
    readonly __typename?: 'SolveNotification';
    /** Number of cuts applied so far */
    readonly cutCount?: Maybe<Scalars['Int']['output']>;
    /** The notification's time */
    readonly effectiveAt: Scalars['DateTime']['output'];
    /** Number of LP iterations so far */
    readonly lpIterationCount?: Maybe<Scalars['Int']['output']>;
    /** Relative gap at the time of the notification */
    readonly relativeGap?: Maybe<Scalars['ExtendedFloat']['output']>;
};
export type SolveNotificationConnection = {
    readonly __typename?: 'SolveNotificationConnection';
    readonly edges: ReadonlyArray<SolveNotificationEdge>;
    readonly pageInfo: PageInfo;
    readonly totalCount: Scalars['Int']['output'];
};
export type SolveNotificationEdge = {
    readonly __typename?: 'SolveNotificationEdge';
    readonly cursor: Scalars['Cursor']['output'];
    readonly node: SolveNotification;
};
export type Specification = Node & {
    readonly __typename?: 'Specification';
    /** Returns attempts for this specification, sorted by start time */
    readonly attempts: AttemptConnection;
    readonly createdAt: Scalars['DateTime']['output'];
    /** Raw source definitions */
    readonly definitions: ReadonlyArray<Scalars['Definition']['output']>;
    /** Background about the specification */
    readonly description: Scalars['Description']['output'];
    /**
     * Time after which the specification becomes eligible for GC. Null if the
     * specification has at least one active tag.
     */
    readonly expiresAt?: Maybe<Scalars['DateTime']['output']>;
    /** Matching formulation */
    readonly formulation: Formulation;
    readonly id: Scalars['ID']['output'];
    /** Parsed definitions */
    readonly outline: Scalars['Outline']['output'];
    /** Specification revision number */
    readonly revno: Scalars['Int']['output'];
    /**
     * Tags currently pointing to this specification. Note that this may differ from
     * the ones set at creation since other specifications may have superseded this
     * one.
     */
    readonly tags: ReadonlyArray<SpecificationTag>;
};
export type SpecificationAttemptsArgs = {
    before?: InputMaybe<Scalars['Cursor']['input']>;
    filter?: InputMaybe<AttemptFilter>;
    last: Scalars['AttemptLimit']['input'];
};
export type SpecificationConnection = {
    readonly __typename?: 'SpecificationConnection';
    readonly edges: ReadonlyArray<SpecificationEdge>;
    readonly pageInfo: PageInfo;
    readonly totalCount: Scalars['Int']['output'];
};
export type SpecificationEdge = {
    readonly __typename?: 'SpecificationEdge';
    readonly cursor: Scalars['Cursor']['output'];
    readonly node: Specification;
};
export type SpecificationTag = Node & {
    readonly __typename?: 'SpecificationTag';
    readonly createdAt: Scalars['DateTime']['output'];
    readonly id: Scalars['ID']['output'];
    readonly isStandard: Scalars['Boolean']['output'];
    /**
     * The most recent time at which the tag was updated to point to a different
     * specification
     */
    readonly lastUpdatedAt: Scalars['DateTime']['output'];
    readonly name: Scalars['TagName']['output'];
    readonly specification: Specification;
};
export type SpecificationTagConnection = {
    readonly __typename?: 'SpecificationTagConnection';
    readonly edges: ReadonlyArray<SpecificationTagEdge>;
    readonly pageInfo: PageInfo;
    readonly totalCount: Scalars['Int']['output'];
};
export type SpecificationTagEdge = {
    readonly __typename?: 'SpecificationTagEdge';
    readonly cursor: Scalars['Cursor']['output'];
    readonly node: SpecificationTag;
};
export type TagSpecificationInput = {
    readonly formulationName: Scalars['FormulationName']['input'];
    /** Names of the tags to add */
    readonly names: ReadonlyArray<Scalars['TagName']['input']>;
    readonly specificationRevno: Scalars['Int']['input'];
};
export type UpdateFormulationInput = {
    readonly name: Scalars['FormulationName']['input'];
    readonly patch: FormulationPatch;
};
export type Requester<C = {}, E = unknown> = <R, V>(doc: string, vars?: V, options?: C) => Promise<ExecutionResult<R, E>> | AsyncIterable<ExecutionResult<R, E>>;
export declare function getSdk<C, E>(requester: Requester<C, E>): {
    CancelQueuedSolve(variables: CancelQueuedSolveMutationVariables, options?: C): Promise<ExecutionResult<CancelQueuedSolveMutation, E>>;
    DeleteFormulation(variables: DeleteFormulationMutationVariables, options?: C): Promise<ExecutionResult<DeleteFormulationMutation, E>>;
    GenerateAuthorization(variables: GenerateAuthorizationMutationVariables, options?: C): Promise<ExecutionResult<GenerateAuthorizationMutation, E>>;
    RegisterSpecification(variables: RegisterSpecificationMutationVariables, options?: C): Promise<ExecutionResult<RegisterSpecificationMutation, E>>;
    RevokeAuthorization(variables: RevokeAuthorizationMutationVariables, options?: C): Promise<ExecutionResult<RevokeAuthorizationMutation, E>>;
    UpdateFormulation(variables: UpdateFormulationMutationVariables, options?: C): Promise<ExecutionResult<UpdateFormulationMutation, E>>;
    FetchFormulation(variables: FetchFormulationQueryVariables, options?: C): Promise<ExecutionResult<FetchFormulationQuery, E>>;
    FetchMember(variables?: FetchMemberQueryVariables, options?: C): Promise<ExecutionResult<FetchMemberQuery, E>>;
    FetchQueuedSolveSummaries(variables: FetchQueuedSolveSummariesQueryVariables, options?: C): Promise<ExecutionResult<FetchQueuedSolveSummariesQuery, E>>;
    FetchQueuedSolve(variables: FetchQueuedSolveQueryVariables, options?: C): Promise<ExecutionResult<FetchQueuedSolveQuery, E>>;
    FetchOutline(variables: FetchOutlineQueryVariables, options?: C): Promise<ExecutionResult<FetchOutlineQuery, E>>;
    FetchSpecificationTag(variables: FetchSpecificationTagQueryVariables, options?: C): Promise<ExecutionResult<FetchSpecificationTagQuery, E>>;
    FetchSpecification(variables: FetchSpecificationQueryVariables, options?: C): Promise<ExecutionResult<FetchSpecificationQuery, E>>;
    ListAuthorizations(variables?: ListAuthorizationsQueryVariables, options?: C): Promise<ExecutionResult<ListAuthorizationsQuery, E>>;
    PaginateAttempts(variables?: PaginateAttemptsQueryVariables, options?: C): Promise<ExecutionResult<PaginateAttemptsQuery, E>>;
    PaginateCreditCharges(variables?: PaginateCreditChargesQueryVariables, options?: C): Promise<ExecutionResult<PaginateCreditChargesQuery, E>>;
    PaginateCreditGrants(variables?: PaginateCreditGrantsQueryVariables, options?: C): Promise<ExecutionResult<PaginateCreditGrantsQuery, E>>;
    PaginateFormulationAttempts(variables: PaginateFormulationAttemptsQueryVariables, options?: C): Promise<ExecutionResult<PaginateFormulationAttemptsQuery, E>>;
    PaginateFormulationSpecifications(variables: PaginateFormulationSpecificationsQueryVariables, options?: C): Promise<ExecutionResult<PaginateFormulationSpecificationsQuery, E>>;
    PaginateFormulationTags(variables: PaginateFormulationTagsQueryVariables, options?: C): Promise<ExecutionResult<PaginateFormulationTagsQuery, E>>;
    PaginateFormulations(variables?: PaginateFormulationsQueryVariables, options?: C): Promise<ExecutionResult<PaginateFormulationsQuery, E>>;
    PaginateQueuedSolveAttempts(variables?: PaginateQueuedSolveAttemptsQueryVariables, options?: C): Promise<ExecutionResult<PaginateQueuedSolveAttemptsQuery, E>>;
    PaginateQueuedSolveNotifications(variables: PaginateQueuedSolveNotificationsQueryVariables, options?: C): Promise<ExecutionResult<PaginateQueuedSolveNotificationsQuery, E>>;
    PollQueuedSolve(variables: PollQueuedSolveQueryVariables, options?: C): Promise<ExecutionResult<PollQueuedSolveQuery, E>>;
};
export type Sdk = ReturnType<typeof getSdk>;
export type ShallowSpecificationTagFragment = {
    readonly __typename?: 'SpecificationTag';
    readonly name: string;
    readonly createdAt: string;
    readonly lastUpdatedAt: string;
};
export type SpecificationForOverviewFragment = {
    readonly __typename?: 'Specification';
    readonly revno: number;
    readonly createdAt: string;
    readonly expiresAt?: string | undefined;
    readonly description: string;
    readonly definitions: ReadonlyArray<Schema<'Definition'>>;
    readonly outline: Schema<'Outline'>;
    readonly tags: ReadonlyArray<{
        readonly __typename?: 'SpecificationTag';
        readonly name: string;
        readonly createdAt: string;
        readonly lastUpdatedAt: string;
    }>;
};
export type AttemptForRowFragment = {
    readonly __typename?: 'Attempt';
    readonly id: string;
    readonly operation: Schema<'AttemptOperation'>;
    readonly annotations: ReadonlyArray<Schema<'Annotation'>>;
    readonly problemSize: Schema<'ProblemSize'>;
    readonly chargeAmount: number;
    readonly tier: Schema<'AttemptTier'>;
    readonly startedAt: string;
    readonly endedAt?: string | undefined;
    readonly errorStatus?: string | undefined;
    readonly content?: {
        readonly __typename: 'QueuedSolve';
        readonly queuedSolveUuid: string;
    } | undefined;
};
export type ShallowAttemptFragment = {
    readonly __typename?: 'Attempt';
    readonly id: string;
    readonly annotations: ReadonlyArray<Schema<'Annotation'>>;
    readonly startedAt: string;
    readonly endedAt?: string | undefined;
    readonly errorStatus?: string | undefined;
};
export type ShallowQueuedSolveFragment = {
    readonly __typename?: 'QueuedSolve';
    readonly uuid: string;
    readonly dequeuedAt?: string | undefined;
    readonly expiresAt: string;
    readonly specificationTagName: string;
    readonly transformations: ReadonlyArray<Schema<'Transformation'>>;
    readonly strategy?: Schema<'SolveStrategy'> | undefined;
    readonly options: Schema<'SolveOptions'>;
    readonly problemSummary?: Schema<'ProblemSummary'> | undefined;
    readonly solutionSummary?: Schema<'SolutionSummary'> | undefined;
    readonly outcome?: Schema<'SolveOutcome'> | undefined;
    readonly failure?: Schema<'Failure'> | undefined;
    readonly specification: {
        readonly __typename?: 'Specification';
        readonly id: string;
    };
};
export type FullCreditChargeFragment = {
    readonly __typename?: 'CreditCharge';
    readonly id: string;
    readonly amount: number;
    readonly createdAt: string;
    readonly product: {
        readonly __typename: 'PerformanceAttempt';
        readonly problemSize: string;
        readonly attemptOperation: string;
    };
};
export type FullCreditGrantFragment = {
    readonly __typename?: 'CreditGrant';
    readonly id: string;
    readonly amount: number;
    readonly createdAt: string;
    readonly reason?: string | undefined;
};
export type FullSolveNotificationFragment = {
    readonly __typename?: 'SolveNotification';
    readonly effectiveAt: string;
    readonly relativeGap?: Schema<'ExtendedFloat'> | undefined;
    readonly lpIterationCount?: number | undefined;
    readonly cutCount?: number | undefined;
};
export type FullPageInfoFragment = {
    readonly __typename?: 'PageInfo';
    readonly startCursor: string;
    readonly endCursor: string;
    readonly hasPreviousPage: boolean;
    readonly hasNextPage: boolean;
};
export type CancelQueuedSolveMutationVariables = Exact<{
    uuid: Scalars['Uuid']['input'];
}>;
export type CancelQueuedSolveMutation = {
    readonly __typename?: 'Mutation';
    readonly cancelQueuedSolve: boolean;
};
export type DeleteFormulationMutationVariables = Exact<{
    name: Scalars['FormulationName']['input'];
}>;
export type DeleteFormulationMutation = {
    readonly __typename?: 'Mutation';
    readonly deleteFormulation: {
        readonly __typename?: 'DeleteFormulationOutput';
        readonly specificationCount: number;
        readonly attemptCount: number;
    };
};
export type DeletedFormulationFragment = {
    readonly __typename?: 'DeleteFormulationOutput';
    readonly specificationCount: number;
    readonly attemptCount: number;
};
export type GenerateAuthorizationMutationVariables = Exact<{
    input: GenerateAuthorizationInput;
}>;
export type GenerateAuthorizationMutation = {
    readonly __typename?: 'Mutation';
    readonly generateAuthorization: {
        readonly __typename?: 'GeneratedAuthorization';
        readonly token: string;
    };
};
export type RegisterSpecificationMutationVariables = Exact<{
    input: RegisterSpecificationInput;
}>;
export type RegisterSpecificationMutation = {
    readonly __typename?: 'Mutation';
    readonly registerSpecification: {
        readonly __typename?: 'Specification';
        readonly revno: number;
        readonly createdAt: string;
        readonly expiresAt?: string | undefined;
        readonly description: string;
        readonly definitions: ReadonlyArray<Schema<'Definition'>>;
        readonly outline: Schema<'Outline'>;
        readonly formulation: {
            readonly __typename?: 'Formulation';
            readonly id: string;
            readonly name: string;
            readonly displayName: string;
            readonly createdAt: string;
        };
        readonly tags: ReadonlyArray<{
            readonly __typename?: 'SpecificationTag';
            readonly name: string;
            readonly createdAt: string;
            readonly lastUpdatedAt: string;
        }>;
    };
};
export type RegisteredSpecificationFragment = {
    readonly __typename?: 'Specification';
    readonly revno: number;
    readonly createdAt: string;
    readonly expiresAt?: string | undefined;
    readonly description: string;
    readonly definitions: ReadonlyArray<Schema<'Definition'>>;
    readonly outline: Schema<'Outline'>;
    readonly formulation: {
        readonly __typename?: 'Formulation';
        readonly id: string;
        readonly name: string;
        readonly displayName: string;
        readonly createdAt: string;
    };
    readonly tags: ReadonlyArray<{
        readonly __typename?: 'SpecificationTag';
        readonly name: string;
        readonly createdAt: string;
        readonly lastUpdatedAt: string;
    }>;
};
export type RevokeAuthorizationMutationVariables = Exact<{
    name: Scalars['AuthorizationName']['input'];
}>;
export type RevokeAuthorizationMutation = {
    readonly __typename?: 'Mutation';
    readonly revokeAuthorization: boolean;
};
export type UpdateFormulationMutationVariables = Exact<{
    input: UpdateFormulationInput;
}>;
export type UpdateFormulationMutation = {
    readonly __typename?: 'Mutation';
    readonly updateFormulation: {
        readonly __typename?: 'Formulation';
        readonly name: string;
        readonly displayName: string;
        readonly createdAt: string;
        readonly defaultTagName: string;
    };
};
export type UpdatedFormulationFragment = {
    readonly __typename?: 'Formulation';
    readonly name: string;
    readonly displayName: string;
    readonly createdAt: string;
    readonly defaultTagName: string;
};
export type FetchFormulationQueryVariables = Exact<{
    name: Scalars['FormulationName']['input'];
}>;
export type FetchFormulationQuery = {
    readonly __typename?: 'Query';
    readonly formulation?: {
        readonly __typename?: 'Formulation';
        readonly id: string;
        readonly name: string;
        readonly displayName: string;
        readonly createdAt: string;
        readonly lastSpecifiedAt: string;
        readonly defaultTagName: string;
        readonly specifications: {
            readonly __typename?: 'SpecificationConnection';
            readonly totalCount: number;
        };
        readonly sharedTags: {
            readonly __typename?: 'SpecificationTagConnection';
            readonly totalCount: number;
        };
        readonly attempts: {
            readonly __typename?: 'AttemptConnection';
            readonly totalCount: number;
            readonly edges: ReadonlyArray<{
                readonly __typename?: 'AttemptEdge';
                readonly node: {
                    readonly __typename?: 'Attempt';
                    readonly startedAt: string;
                };
            }>;
        };
    } | undefined;
};
export type FetchedFormulationFragment = {
    readonly __typename?: 'Formulation';
    readonly id: string;
    readonly name: string;
    readonly displayName: string;
    readonly createdAt: string;
    readonly lastSpecifiedAt: string;
    readonly defaultTagName: string;
    readonly specifications: {
        readonly __typename?: 'SpecificationConnection';
        readonly totalCount: number;
    };
    readonly sharedTags: {
        readonly __typename?: 'SpecificationTagConnection';
        readonly totalCount: number;
    };
    readonly attempts: {
        readonly __typename?: 'AttemptConnection';
        readonly totalCount: number;
        readonly edges: ReadonlyArray<{
            readonly __typename?: 'AttemptEdge';
            readonly node: {
                readonly __typename?: 'Attempt';
                readonly startedAt: string;
            };
        }>;
    };
};
export type FetchMemberQueryVariables = Exact<{
    [key: string]: never;
}>;
export type FetchMemberQuery = {
    readonly __typename?: 'Query';
    readonly me: {
        readonly __typename?: 'Member';
        readonly registeredAt: string;
        readonly email: string;
        readonly creditBalance: number;
    };
};
export type FetchedMemberFragment = {
    readonly __typename?: 'Member';
    readonly registeredAt: string;
    readonly email: string;
    readonly creditBalance: number;
};
export type FetchQueuedSolveSummariesQueryVariables = Exact<{
    uuid: Scalars['Uuid']['input'];
}>;
export type FetchQueuedSolveSummariesQuery = {
    readonly __typename?: 'Query';
    readonly queuedSolve?: {
        readonly __typename?: 'QueuedSolve';
        readonly problemSummary?: Schema<'ProblemSummary'> | undefined;
        readonly solutionSummary?: Schema<'SolutionSummary'> | undefined;
    } | undefined;
};
export type FetchQueuedSolveQueryVariables = Exact<{
    uuid: Scalars['Uuid']['input'];
}>;
export type FetchQueuedSolveQuery = {
    readonly __typename?: 'Query';
    readonly queuedSolve?: {
        readonly __typename?: 'QueuedSolve';
        readonly specificationTagName: string;
        readonly uuid: string;
        readonly dequeuedAt?: string | undefined;
        readonly expiresAt: string;
        readonly transformations: ReadonlyArray<Schema<'Transformation'>>;
        readonly strategy?: Schema<'SolveStrategy'> | undefined;
        readonly options: Schema<'SolveOptions'>;
        readonly problemSummary?: Schema<'ProblemSummary'> | undefined;
        readonly solutionSummary?: Schema<'SolutionSummary'> | undefined;
        readonly outcome?: Schema<'SolveOutcome'> | undefined;
        readonly failure?: Schema<'Failure'> | undefined;
        readonly attempt: {
            readonly __typename?: 'Attempt';
            readonly id: string;
            readonly annotations: ReadonlyArray<Schema<'Annotation'>>;
            readonly startedAt: string;
            readonly endedAt?: string | undefined;
            readonly errorStatus?: string | undefined;
        };
        readonly specification: {
            readonly __typename?: 'Specification';
            readonly revno: number;
            readonly outline: Schema<'Outline'>;
            readonly id: string;
            readonly formulation: {
                readonly __typename?: 'Formulation';
                readonly id: string;
                readonly name: string;
            };
        };
    } | undefined;
};
export type FetchedQueuedSolveFragment = {
    readonly __typename?: 'QueuedSolve';
    readonly specificationTagName: string;
    readonly uuid: string;
    readonly dequeuedAt?: string | undefined;
    readonly expiresAt: string;
    readonly transformations: ReadonlyArray<Schema<'Transformation'>>;
    readonly strategy?: Schema<'SolveStrategy'> | undefined;
    readonly options: Schema<'SolveOptions'>;
    readonly problemSummary?: Schema<'ProblemSummary'> | undefined;
    readonly solutionSummary?: Schema<'SolutionSummary'> | undefined;
    readonly outcome?: Schema<'SolveOutcome'> | undefined;
    readonly failure?: Schema<'Failure'> | undefined;
    readonly attempt: {
        readonly __typename?: 'Attempt';
        readonly id: string;
        readonly annotations: ReadonlyArray<Schema<'Annotation'>>;
        readonly startedAt: string;
        readonly endedAt?: string | undefined;
        readonly errorStatus?: string | undefined;
    };
    readonly specification: {
        readonly __typename?: 'Specification';
        readonly revno: number;
        readonly outline: Schema<'Outline'>;
        readonly id: string;
        readonly formulation: {
            readonly __typename?: 'Formulation';
            readonly id: string;
            readonly name: string;
        };
    };
};
export type FetchOutlineQueryVariables = Exact<{
    formulationName: Scalars['FormulationName']['input'];
    tagName?: InputMaybe<Scalars['TagName']['input']>;
}>;
export type FetchOutlineQuery = {
    readonly __typename?: 'Query';
    readonly formulation?: {
        readonly __typename?: 'Formulation';
        readonly name: string;
        readonly displayName: string;
        readonly tag?: {
            readonly __typename?: 'SpecificationTag';
            readonly name: string;
            readonly specification: {
                readonly __typename?: 'Specification';
                readonly revno: number;
                readonly outline: Schema<'Outline'>;
            };
        } | undefined;
    } | undefined;
};
export type FetchedOutlineFormulationFragment = {
    readonly __typename?: 'Formulation';
    readonly name: string;
    readonly displayName: string;
    readonly tag?: {
        readonly __typename?: 'SpecificationTag';
        readonly name: string;
        readonly specification: {
            readonly __typename?: 'Specification';
            readonly revno: number;
            readonly outline: Schema<'Outline'>;
        };
    } | undefined;
};
export type FetchSpecificationTagQueryVariables = Exact<{
    formulationName: Scalars['FormulationName']['input'];
    name?: InputMaybe<Scalars['TagName']['input']>;
}>;
export type FetchSpecificationTagQuery = {
    readonly __typename?: 'Query';
    readonly formulation?: {
        readonly __typename?: 'Formulation';
        readonly name: string;
        readonly displayName: string;
        readonly tag?: {
            readonly __typename?: 'SpecificationTag';
            readonly name: string;
            readonly createdAt: string;
            readonly lastUpdatedAt: string;
            readonly specification: {
                readonly __typename?: 'Specification';
                readonly revno: number;
                readonly createdAt: string;
                readonly expiresAt?: string | undefined;
                readonly description: string;
                readonly definitions: ReadonlyArray<Schema<'Definition'>>;
                readonly outline: Schema<'Outline'>;
                readonly tags: ReadonlyArray<{
                    readonly __typename?: 'SpecificationTag';
                    readonly name: string;
                    readonly createdAt: string;
                    readonly lastUpdatedAt: string;
                }>;
            };
        } | undefined;
    } | undefined;
};
export type FetchedSpecificationTagFormulationFragment = {
    readonly __typename?: 'Formulation';
    readonly name: string;
    readonly displayName: string;
    readonly tag?: {
        readonly __typename?: 'SpecificationTag';
        readonly name: string;
        readonly createdAt: string;
        readonly lastUpdatedAt: string;
        readonly specification: {
            readonly __typename?: 'Specification';
            readonly revno: number;
            readonly createdAt: string;
            readonly expiresAt?: string | undefined;
            readonly description: string;
            readonly definitions: ReadonlyArray<Schema<'Definition'>>;
            readonly outline: Schema<'Outline'>;
            readonly tags: ReadonlyArray<{
                readonly __typename?: 'SpecificationTag';
                readonly name: string;
                readonly createdAt: string;
                readonly lastUpdatedAt: string;
            }>;
        };
    } | undefined;
};
export type FetchedSpecificationTagFragment = {
    readonly __typename?: 'SpecificationTag';
    readonly name: string;
    readonly createdAt: string;
    readonly lastUpdatedAt: string;
    readonly specification: {
        readonly __typename?: 'Specification';
        readonly revno: number;
        readonly createdAt: string;
        readonly expiresAt?: string | undefined;
        readonly description: string;
        readonly definitions: ReadonlyArray<Schema<'Definition'>>;
        readonly outline: Schema<'Outline'>;
        readonly tags: ReadonlyArray<{
            readonly __typename?: 'SpecificationTag';
            readonly name: string;
            readonly createdAt: string;
            readonly lastUpdatedAt: string;
        }>;
    };
};
export type FetchSpecificationQueryVariables = Exact<{
    formulationName: Scalars['FormulationName']['input'];
    revno: Scalars['Int']['input'];
}>;
export type FetchSpecificationQuery = {
    readonly __typename?: 'Query';
    readonly formulation?: {
        readonly __typename?: 'Formulation';
        readonly name: string;
        readonly displayName: string;
        readonly specification?: {
            readonly __typename?: 'Specification';
            readonly revno: number;
            readonly createdAt: string;
            readonly expiresAt?: string | undefined;
            readonly description: string;
            readonly definitions: ReadonlyArray<Schema<'Definition'>>;
            readonly outline: Schema<'Outline'>;
            readonly tags: ReadonlyArray<{
                readonly __typename?: 'SpecificationTag';
                readonly name: string;
                readonly createdAt: string;
                readonly lastUpdatedAt: string;
            }>;
        } | undefined;
    } | undefined;
};
export type FetchedSpecificationFormulationFragment = {
    readonly __typename?: 'Formulation';
    readonly name: string;
    readonly displayName: string;
    readonly specification?: {
        readonly __typename?: 'Specification';
        readonly revno: number;
        readonly createdAt: string;
        readonly expiresAt?: string | undefined;
        readonly description: string;
        readonly definitions: ReadonlyArray<Schema<'Definition'>>;
        readonly outline: Schema<'Outline'>;
        readonly tags: ReadonlyArray<{
            readonly __typename?: 'SpecificationTag';
            readonly name: string;
            readonly createdAt: string;
            readonly lastUpdatedAt: string;
        }>;
    } | undefined;
};
export type ListAuthorizationsQueryVariables = Exact<{
    [key: string]: never;
}>;
export type ListAuthorizationsQuery = {
    readonly __typename?: 'Query';
    readonly me: {
        readonly __typename?: 'Member';
        readonly authorizations: ReadonlyArray<{
            readonly __typename?: 'Authorization';
            readonly id: string;
            readonly name: string;
            readonly createdAt: string;
            readonly lastUsedAt?: string | undefined;
            readonly expiresAt: string;
            readonly tokenSuffix: string;
        }>;
    };
};
export type ListedAuthorizationFragment = {
    readonly __typename?: 'Authorization';
    readonly id: string;
    readonly name: string;
    readonly createdAt: string;
    readonly lastUsedAt?: string | undefined;
    readonly expiresAt: string;
    readonly tokenSuffix: string;
};
export type PaginateAttemptsQueryVariables = Exact<{
    first?: InputMaybe<Scalars['AttemptLimit']['input']>;
    after?: InputMaybe<Scalars['Cursor']['input']>;
    last?: InputMaybe<Scalars['AttemptLimit']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    filter?: InputMaybe<AttemptFilter>;
}>;
export type PaginateAttemptsQuery = {
    readonly __typename?: 'Query';
    readonly attempts: {
        readonly __typename?: 'AttemptConnection';
        readonly totalCount: number;
        readonly edges: ReadonlyArray<{
            readonly __typename?: 'AttemptEdge';
            readonly node: {
                readonly __typename?: 'Attempt';
                readonly id: string;
                readonly operation: Schema<'AttemptOperation'>;
                readonly annotations: ReadonlyArray<Schema<'Annotation'>>;
                readonly problemSize: Schema<'ProblemSize'>;
                readonly chargeAmount: number;
                readonly tier: Schema<'AttemptTier'>;
                readonly startedAt: string;
                readonly endedAt?: string | undefined;
                readonly errorStatus?: string | undefined;
                readonly content?: {
                    readonly __typename: 'QueuedSolve';
                    readonly queuedSolveOutcome?: Schema<'SolveOutcome'> | undefined;
                    readonly queuedSolveFailure?: Schema<'Failure'> | undefined;
                    readonly queuedSolveUuid: string;
                    readonly queuedSolveSpecification: {
                        readonly __typename?: 'Specification';
                        readonly revno: number;
                        readonly formulation: {
                            readonly __typename?: 'Formulation';
                            readonly name: string;
                            readonly displayName: string;
                        };
                    };
                } | undefined;
            };
        }>;
        readonly pageInfo: {
            readonly __typename?: 'PageInfo';
            readonly startCursor: string;
            readonly endCursor: string;
            readonly hasPreviousPage: boolean;
            readonly hasNextPage: boolean;
        };
    };
};
export type PaginatedAttemptFragment = {
    readonly __typename?: 'Attempt';
    readonly id: string;
    readonly operation: Schema<'AttemptOperation'>;
    readonly annotations: ReadonlyArray<Schema<'Annotation'>>;
    readonly problemSize: Schema<'ProblemSize'>;
    readonly chargeAmount: number;
    readonly tier: Schema<'AttemptTier'>;
    readonly startedAt: string;
    readonly endedAt?: string | undefined;
    readonly errorStatus?: string | undefined;
    readonly content?: {
        readonly __typename: 'QueuedSolve';
        readonly queuedSolveOutcome?: Schema<'SolveOutcome'> | undefined;
        readonly queuedSolveFailure?: Schema<'Failure'> | undefined;
        readonly queuedSolveUuid: string;
        readonly queuedSolveSpecification: {
            readonly __typename?: 'Specification';
            readonly revno: number;
            readonly formulation: {
                readonly __typename?: 'Formulation';
                readonly name: string;
                readonly displayName: string;
            };
        };
    } | undefined;
};
export type PaginateCreditChargesQueryVariables = Exact<{
    first?: InputMaybe<Scalars['CreditChargeLimit']['input']>;
    last?: InputMaybe<Scalars['CreditChargeLimit']['input']>;
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
}>;
export type PaginateCreditChargesQuery = {
    readonly __typename?: 'Query';
    readonly me: {
        readonly __typename?: 'Member';
        readonly creditCharges: {
            readonly __typename?: 'CreditChargeConnection';
            readonly totalCount: number;
            readonly edges: ReadonlyArray<{
                readonly __typename?: 'CreditChargeEdge';
                readonly node: {
                    readonly __typename?: 'CreditCharge';
                    readonly id: string;
                    readonly amount: number;
                    readonly createdAt: string;
                    readonly product: {
                        readonly __typename: 'PerformanceAttempt';
                        readonly problemSize: string;
                        readonly attemptOperation: string;
                    };
                };
            }>;
            readonly pageInfo: {
                readonly __typename?: 'PageInfo';
                readonly startCursor: string;
                readonly endCursor: string;
                readonly hasPreviousPage: boolean;
                readonly hasNextPage: boolean;
            };
        };
    };
};
export type PaginateCreditGrantsQueryVariables = Exact<{
    first?: InputMaybe<Scalars['CreditGrantLimit']['input']>;
    last?: InputMaybe<Scalars['CreditGrantLimit']['input']>;
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
}>;
export type PaginateCreditGrantsQuery = {
    readonly __typename?: 'Query';
    readonly me: {
        readonly __typename?: 'Member';
        readonly creditGrants: {
            readonly __typename?: 'CreditGrantConnection';
            readonly totalCount: number;
            readonly edges: ReadonlyArray<{
                readonly __typename?: 'CreditGrantEdge';
                readonly node: {
                    readonly __typename?: 'CreditGrant';
                    readonly id: string;
                    readonly amount: number;
                    readonly createdAt: string;
                    readonly reason?: string | undefined;
                };
            }>;
            readonly pageInfo: {
                readonly __typename?: 'PageInfo';
                readonly startCursor: string;
                readonly endCursor: string;
                readonly hasPreviousPage: boolean;
                readonly hasNextPage: boolean;
            };
        };
    };
};
export type PaginateFormulationAttemptsQueryVariables = Exact<{
    name: Scalars['FormulationName']['input'];
    last: Scalars['AttemptLimit']['input'];
    before?: InputMaybe<Scalars['Cursor']['input']>;
    filter?: InputMaybe<AttemptFilter>;
}>;
export type PaginateFormulationAttemptsQuery = {
    readonly __typename?: 'Query';
    readonly formulation?: {
        readonly __typename?: 'Formulation';
        readonly attempts: {
            readonly __typename?: 'AttemptConnection';
            readonly totalCount: number;
            readonly edges: ReadonlyArray<{
                readonly __typename?: 'AttemptEdge';
                readonly node: {
                    readonly __typename?: 'Attempt';
                    readonly id: string;
                    readonly annotations: ReadonlyArray<Schema<'Annotation'>>;
                    readonly startedAt: string;
                    readonly endedAt?: string | undefined;
                    readonly errorStatus?: string | undefined;
                    readonly content?: {
                        readonly __typename?: 'QueuedSolve';
                        readonly uuid: string;
                        readonly dequeuedAt?: string | undefined;
                        readonly expiresAt: string;
                        readonly specificationTagName: string;
                        readonly transformations: ReadonlyArray<Schema<'Transformation'>>;
                        readonly strategy?: Schema<'SolveStrategy'> | undefined;
                        readonly options: Schema<'SolveOptions'>;
                        readonly problemSummary?: Schema<'ProblemSummary'> | undefined;
                        readonly solutionSummary?: Schema<'SolutionSummary'> | undefined;
                        readonly outcome?: Schema<'SolveOutcome'> | undefined;
                        readonly failure?: Schema<'Failure'> | undefined;
                        readonly specification: {
                            readonly __typename?: 'Specification';
                            readonly id: string;
                        };
                    } | undefined;
                };
            }>;
            readonly pageInfo: {
                readonly __typename?: 'PageInfo';
                readonly startCursor: string;
                readonly hasPreviousPage: boolean;
            };
        };
    } | undefined;
};
export type PaginatedFormulationAttemptFragment = {
    readonly __typename?: 'Attempt';
    readonly id: string;
    readonly annotations: ReadonlyArray<Schema<'Annotation'>>;
    readonly startedAt: string;
    readonly endedAt?: string | undefined;
    readonly errorStatus?: string | undefined;
    readonly content?: {
        readonly __typename?: 'QueuedSolve';
        readonly uuid: string;
        readonly dequeuedAt?: string | undefined;
        readonly expiresAt: string;
        readonly specificationTagName: string;
        readonly transformations: ReadonlyArray<Schema<'Transformation'>>;
        readonly strategy?: Schema<'SolveStrategy'> | undefined;
        readonly options: Schema<'SolveOptions'>;
        readonly problemSummary?: Schema<'ProblemSummary'> | undefined;
        readonly solutionSummary?: Schema<'SolutionSummary'> | undefined;
        readonly outcome?: Schema<'SolveOutcome'> | undefined;
        readonly failure?: Schema<'Failure'> | undefined;
        readonly specification: {
            readonly __typename?: 'Specification';
            readonly id: string;
        };
    } | undefined;
};
export type PaginateFormulationSpecificationsQueryVariables = Exact<{
    formulationName: Scalars['FormulationName']['input'];
    first?: InputMaybe<Scalars['Limit']['input']>;
    after?: InputMaybe<Scalars['Cursor']['input']>;
    last?: InputMaybe<Scalars['Limit']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
}>;
export type PaginateFormulationSpecificationsQuery = {
    readonly __typename?: 'Query';
    readonly formulation?: {
        readonly __typename?: 'Formulation';
        readonly specifications: {
            readonly __typename?: 'SpecificationConnection';
            readonly totalCount: number;
            readonly edges: ReadonlyArray<{
                readonly __typename?: 'SpecificationEdge';
                readonly node: {
                    readonly __typename?: 'Specification';
                    readonly id: string;
                    readonly revno: number;
                    readonly createdAt: string;
                    readonly expiresAt?: string | undefined;
                    readonly tags: ReadonlyArray<{
                        readonly __typename?: 'SpecificationTag';
                        readonly name: string;
                        readonly createdAt: string;
                        readonly lastUpdatedAt: string;
                    }>;
                };
            }>;
            readonly pageInfo: {
                readonly __typename?: 'PageInfo';
                readonly startCursor: string;
                readonly endCursor: string;
                readonly hasPreviousPage: boolean;
                readonly hasNextPage: boolean;
            };
        };
    } | undefined;
};
export type PaginatedFormulationSpecificationFragment = {
    readonly __typename?: 'Specification';
    readonly id: string;
    readonly revno: number;
    readonly createdAt: string;
    readonly expiresAt?: string | undefined;
    readonly tags: ReadonlyArray<{
        readonly __typename?: 'SpecificationTag';
        readonly name: string;
        readonly createdAt: string;
        readonly lastUpdatedAt: string;
    }>;
};
export type PaginateFormulationTagsQueryVariables = Exact<{
    formulationName: Scalars['FormulationName']['input'];
    first: Scalars['Limit']['input'];
    after?: InputMaybe<Scalars['Cursor']['input']>;
    filter?: InputMaybe<FormulationTagsFilter>;
}>;
export type PaginateFormulationTagsQuery = {
    readonly __typename?: 'Query';
    readonly formulation?: {
        readonly __typename?: 'Formulation';
        readonly tags: {
            readonly __typename?: 'SpecificationTagConnection';
            readonly totalCount: number;
            readonly edges: ReadonlyArray<{
                readonly __typename?: 'SpecificationTagEdge';
                readonly node: {
                    readonly __typename?: 'SpecificationTag';
                    readonly id: string;
                    readonly name: string;
                    readonly createdAt: string;
                    readonly lastUpdatedAt: string;
                    readonly isStandard: boolean;
                    readonly specification: {
                        readonly __typename?: 'Specification';
                        readonly id: string;
                        readonly revno: number;
                        readonly createdAt: string;
                        readonly expiresAt?: string | undefined;
                        readonly outline: Schema<'Outline'>;
                    };
                };
            }>;
            readonly pageInfo: {
                readonly __typename?: 'PageInfo';
                readonly startCursor: string;
                readonly endCursor: string;
                readonly hasPreviousPage: boolean;
                readonly hasNextPage: boolean;
            };
        };
    } | undefined;
};
export type PaginatedFormulationTagFragment = {
    readonly __typename?: 'SpecificationTag';
    readonly id: string;
    readonly name: string;
    readonly createdAt: string;
    readonly lastUpdatedAt: string;
    readonly isStandard: boolean;
    readonly specification: {
        readonly __typename?: 'Specification';
        readonly id: string;
        readonly revno: number;
        readonly createdAt: string;
        readonly expiresAt?: string | undefined;
        readonly outline: Schema<'Outline'>;
    };
};
export type PaginateFormulationsQueryVariables = Exact<{
    first?: InputMaybe<Scalars['Limit']['input']>;
    after?: InputMaybe<Scalars['Cursor']['input']>;
    last?: InputMaybe<Scalars['Limit']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    filter?: InputMaybe<FormulationFilter>;
    orderBy?: InputMaybe<FormulationOrderBy>;
}>;
export type PaginateFormulationsQuery = {
    readonly __typename?: 'Query';
    readonly formulations: {
        readonly __typename?: 'FormulationConnection';
        readonly totalCount: number;
        readonly edges: ReadonlyArray<{
            readonly __typename?: 'FormulationEdge';
            readonly node: {
                readonly __typename?: 'Formulation';
                readonly id: string;
                readonly name: string;
                readonly displayName: string;
                readonly createdAt: string;
                readonly lastSpecifiedAt: string;
                readonly specifications: {
                    readonly __typename?: 'SpecificationConnection';
                    readonly totalCount: number;
                };
            };
        }>;
        readonly pageInfo: {
            readonly __typename?: 'PageInfo';
            readonly startCursor: string;
            readonly endCursor: string;
            readonly hasPreviousPage: boolean;
            readonly hasNextPage: boolean;
        };
    };
};
export type PaginatedFormulationFragment = {
    readonly __typename?: 'Formulation';
    readonly id: string;
    readonly name: string;
    readonly displayName: string;
    readonly createdAt: string;
    readonly lastSpecifiedAt: string;
    readonly specifications: {
        readonly __typename?: 'SpecificationConnection';
        readonly totalCount: number;
    };
};
export type PaginateQueuedSolveAttemptsQueryVariables = Exact<{
    first?: InputMaybe<Scalars['AttemptLimit']['input']>;
    after?: InputMaybe<Scalars['Cursor']['input']>;
    last?: InputMaybe<Scalars['AttemptLimit']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    filter?: InputMaybe<AttemptFilter>;
}>;
export type PaginateQueuedSolveAttemptsQuery = {
    readonly __typename?: 'Query';
    readonly attempts: {
        readonly __typename?: 'AttemptConnection';
        readonly totalCount: number;
        readonly edges: ReadonlyArray<{
            readonly __typename?: 'AttemptEdge';
            readonly node: {
                readonly __typename?: 'Attempt';
                readonly id: string;
                readonly annotations: ReadonlyArray<Schema<'Annotation'>>;
                readonly startedAt: string;
                readonly endedAt?: string | undefined;
                readonly errorStatus?: string | undefined;
                readonly content?: {
                    readonly __typename?: 'QueuedSolve';
                    readonly uuid: string;
                    readonly dequeuedAt?: string | undefined;
                    readonly expiresAt: string;
                    readonly specificationTagName: string;
                    readonly transformations: ReadonlyArray<Schema<'Transformation'>>;
                    readonly strategy?: Schema<'SolveStrategy'> | undefined;
                    readonly options: Schema<'SolveOptions'>;
                    readonly problemSummary?: Schema<'ProblemSummary'> | undefined;
                    readonly solutionSummary?: Schema<'SolutionSummary'> | undefined;
                    readonly outcome?: Schema<'SolveOutcome'> | undefined;
                    readonly failure?: Schema<'Failure'> | undefined;
                    readonly specification: {
                        readonly __typename?: 'Specification';
                        readonly revno: number;
                        readonly createdAt: string;
                        readonly id: string;
                        readonly formulation: {
                            readonly __typename?: 'Formulation';
                            readonly id: string;
                            readonly name: string;
                            readonly displayName: string;
                        };
                    };
                } | undefined;
            };
        }>;
        readonly pageInfo: {
            readonly __typename?: 'PageInfo';
            readonly startCursor: string;
            readonly endCursor: string;
            readonly hasPreviousPage: boolean;
            readonly hasNextPage: boolean;
        };
    };
};
export type PaginatedQueuedSolveAttemptFragment = {
    readonly __typename?: 'Attempt';
    readonly id: string;
    readonly annotations: ReadonlyArray<Schema<'Annotation'>>;
    readonly startedAt: string;
    readonly endedAt?: string | undefined;
    readonly errorStatus?: string | undefined;
    readonly content?: {
        readonly __typename?: 'QueuedSolve';
        readonly uuid: string;
        readonly dequeuedAt?: string | undefined;
        readonly expiresAt: string;
        readonly specificationTagName: string;
        readonly transformations: ReadonlyArray<Schema<'Transformation'>>;
        readonly strategy?: Schema<'SolveStrategy'> | undefined;
        readonly options: Schema<'SolveOptions'>;
        readonly problemSummary?: Schema<'ProblemSummary'> | undefined;
        readonly solutionSummary?: Schema<'SolutionSummary'> | undefined;
        readonly outcome?: Schema<'SolveOutcome'> | undefined;
        readonly failure?: Schema<'Failure'> | undefined;
        readonly specification: {
            readonly __typename?: 'Specification';
            readonly revno: number;
            readonly createdAt: string;
            readonly id: string;
            readonly formulation: {
                readonly __typename?: 'Formulation';
                readonly id: string;
                readonly name: string;
                readonly displayName: string;
            };
        };
    } | undefined;
};
export type PaginateQueuedSolveNotificationsQueryVariables = Exact<{
    uuid: Scalars['Uuid']['input'];
    last: Scalars['SolveNotificationLimit']['input'];
    before?: InputMaybe<Scalars['Cursor']['input']>;
}>;
export type PaginateQueuedSolveNotificationsQuery = {
    readonly __typename?: 'Query';
    readonly queuedSolve?: {
        readonly __typename?: 'QueuedSolve';
        readonly notifications: {
            readonly __typename?: 'SolveNotificationConnection';
            readonly totalCount: number;
            readonly edges: ReadonlyArray<{
                readonly __typename?: 'SolveNotificationEdge';
                readonly node: {
                    readonly __typename?: 'SolveNotification';
                    readonly effectiveAt: string;
                    readonly relativeGap?: Schema<'ExtendedFloat'> | undefined;
                    readonly lpIterationCount?: number | undefined;
                    readonly cutCount?: number | undefined;
                };
            }>;
            readonly pageInfo: {
                readonly __typename?: 'PageInfo';
                readonly startCursor: string;
                readonly endCursor: string;
                readonly hasPreviousPage: boolean;
                readonly hasNextPage: boolean;
            };
        };
    } | undefined;
};
export type PollQueuedSolveQueryVariables = Exact<{
    uuid: Scalars['Uuid']['input'];
}>;
export type PollQueuedSolveQuery = {
    readonly __typename?: 'Query';
    readonly queuedSolve?: {
        readonly __typename?: 'QueuedSolve';
        readonly uuid: string;
        readonly dequeuedAt?: string | undefined;
        readonly expiresAt: string;
        readonly specificationTagName: string;
        readonly transformations: ReadonlyArray<Schema<'Transformation'>>;
        readonly strategy?: Schema<'SolveStrategy'> | undefined;
        readonly options: Schema<'SolveOptions'>;
        readonly problemSummary?: Schema<'ProblemSummary'> | undefined;
        readonly solutionSummary?: Schema<'SolutionSummary'> | undefined;
        readonly outcome?: Schema<'SolveOutcome'> | undefined;
        readonly failure?: Schema<'Failure'> | undefined;
        readonly attempt: {
            readonly __typename?: 'Attempt';
            readonly id: string;
            readonly annotations: ReadonlyArray<Schema<'Annotation'>>;
            readonly startedAt: string;
            readonly endedAt?: string | undefined;
            readonly errorStatus?: string | undefined;
        };
        readonly notifications: {
            readonly __typename?: 'SolveNotificationConnection';
            readonly edges: ReadonlyArray<{
                readonly __typename?: 'SolveNotificationEdge';
                readonly node: {
                    readonly __typename?: 'SolveNotification';
                    readonly effectiveAt: string;
                    readonly relativeGap?: Schema<'ExtendedFloat'> | undefined;
                    readonly lpIterationCount?: number | undefined;
                    readonly cutCount?: number | undefined;
                };
            }>;
        };
        readonly specification: {
            readonly __typename?: 'Specification';
            readonly id: string;
        };
    } | undefined;
};
export type PolledQueuedSolveFragment = {
    readonly __typename?: 'QueuedSolve';
    readonly uuid: string;
    readonly dequeuedAt?: string | undefined;
    readonly expiresAt: string;
    readonly specificationTagName: string;
    readonly transformations: ReadonlyArray<Schema<'Transformation'>>;
    readonly strategy?: Schema<'SolveStrategy'> | undefined;
    readonly options: Schema<'SolveOptions'>;
    readonly problemSummary?: Schema<'ProblemSummary'> | undefined;
    readonly solutionSummary?: Schema<'SolutionSummary'> | undefined;
    readonly outcome?: Schema<'SolveOutcome'> | undefined;
    readonly failure?: Schema<'Failure'> | undefined;
    readonly attempt: {
        readonly __typename?: 'Attempt';
        readonly id: string;
        readonly annotations: ReadonlyArray<Schema<'Annotation'>>;
        readonly startedAt: string;
        readonly endedAt?: string | undefined;
        readonly errorStatus?: string | undefined;
    };
    readonly notifications: {
        readonly __typename?: 'SolveNotificationConnection';
        readonly edges: ReadonlyArray<{
            readonly __typename?: 'SolveNotificationEdge';
            readonly node: {
                readonly __typename?: 'SolveNotification';
                readonly effectiveAt: string;
                readonly relativeGap?: Schema<'ExtendedFloat'> | undefined;
                readonly lpIterationCount?: number | undefined;
                readonly cutCount?: number | undefined;
            };
        }>;
    };
    readonly specification: {
        readonly __typename?: 'Specification';
        readonly id: string;
    };
};