declare const DEFAULT_ACCEPT = "application/json;q=1, text/*;q=0.5";
declare const DEFAULT_CONTENT_TYPE = "application/json";
type AsyncOrSync<V> = V | Promise<V>;
type Has<N extends number | string | symbol, V> = {
    readonly [K in N]: V;
};
type Get<O, N extends keyof O | string, D = never> = O extends Has<N, infer V> ? V & {} : D;
type Lookup<O, N extends keyof O | string, D = undefined> = O extends Has<N, infer V> ? V & {} : O extends Partial<Has<N, infer V>> ? (V & {}) | undefined : D;
type Exact<T, V> = T extends V ? Exclude<keyof T, keyof V> extends never ? T : never : never;
type Values<O> = O[keyof O];
type KeysOfValues<O> = Values<{
    [K in keyof O]: O[K] extends never ? never : keyof O[K];
}>;
type Asyncify<V extends ReadonlyArray<any>> = V extends ReadonlyArray<infer I> ? AsyncIterable<I> : never;
type OperationTypes<N extends string = string> = {
    readonly [K in N]: OperationType;
};
interface OperationType<R extends ResponsesType = {}, P extends ParametersType = {}> {
    readonly parameters?: P;
    readonly requestBody?: {
        readonly content: ContentTypes;
    };
    readonly responses: R;
}
interface ParametersType<P = {}, Q = {}, H = {}> {
    readonly path?: P;
    readonly query?: Q;
    readonly headers?: H;
}
type ResponsesType = {
    readonly [C in ResponseCode]?: never | {
        readonly content: ContentTypes;
    };
};
type ResponseCodeRange = '2XX' | '3XX' | '4XX' | '5XX';
type ResponseCode = number | ResponseCodeRange | 'default' | string;
interface ContentTypes {
    readonly [M: MimeType]: ContentType;
}
type MimeType = string;
type ContentType = unknown;
interface ContentFormat {
    readonly mimeType: MimeType;
    readonly isBinary?: boolean;
    readonly isStream?: boolean;
}
type WithMimeTypeGlobs<M extends MimeType> = M | MimeTypePrefixes<M> | '*/*';
type MimeTypePrefixes<M extends MimeType> = M extends `${infer P}/${infer _S}` ? `${P}/*` : never;
type SplitMimeTypes<G extends MimeType> = G extends `${infer G1}, ${infer G2}` ? ExtractMimeType<G1> | SplitMimeTypes<G2> : ExtractMimeType<G>;
type ExtractMimeType<G extends MimeType> = G extends `${infer M};${string}` ? M : G;
type ValuesMatchingMimeTypes<O, G extends MimeType> = Values<{
    [M in keyof O & MimeType]: SplitMimeTypes<G> & WithMimeTypeGlobs<M> extends never ? never : O[M];
}>;
type RequestBodyContent<O extends OperationType> = Exclude<Lookup<O, 'requestBody'>, undefined>['content'];
type BodyMimeTypes<O extends OperationType> = RequestBodyContent<O> extends never ? never : keyof RequestBodyContent<O> & MimeType;
type ResponseMimeTypes<R extends ResponsesType, C extends keyof R = keyof R> = KeysOfValues<{
    [P in C]: Get<R[P], 'content'>;
}> & MimeType;
interface SdkConfig<F extends BaseFetch = BaseFetch> {
    /** API server address. */
    readonly address: Address;
    /** Global request headers, overridable in individual requests. */
    readonly headers?: RequestHeaders;
    /**
     * Other global request options. These can similarly be overriden in
     * individual fetch calls.
     */
    readonly options?: RequestOptions<F>;
    /** Underlying fetch method. */
    readonly fetch?: FetchOption<F>;
    /** Global request body encoders. */
    readonly encoders?: Encoders<F>;
    /** Global response decoders. */
    readonly decoders?: Decoders<F>;
    /**
     * Unexpected response coercion. The default will ignore bodies of responses
     * which do not have any declared content and throw an error otherwise.
     */
    readonly coercer?: Coercer<F>;
}
type Address = string | URL | AddressInfo;
interface AddressInfo {
    readonly address: string;
    readonly port: number;
}
type RequestHeaders = Record<string, string>;
interface BaseInit<B = any> {
    readonly body?: B;
    readonly headers: RequestHeaders;
    readonly method: string;
}
interface BaseResponse {
    readonly status: number;
    readonly headers: {
        get(name: string): string | null | undefined;
    };
    blob(): Promise<Blob>;
    json(): Promise<any>;
    text(): Promise<string>;
}
type BaseFetch = (url: string, init?: BaseInit) => Promise<BaseResponse>;
type FetchOption<F extends BaseFetch = BaseFetch> = (url: string, init: BaseInit<BodyInitFor<F>> & RequestOptions<F>) => Promise<ResponseFor<F>>;
type RequestOptions<F> = Omit<RequestInitFor<F>, 'body' | 'headers' | 'method'>;
type RequestInitFor<F> = F extends (url: any, init?: infer R) => any ? R : never;
interface Encoders<F extends BaseFetch> {
    readonly [mimeType: MimeType]: Encoder<F>;
}
type Encoder<F extends BaseFetch = BaseFetch> = (body: unknown, ctx: EncoderContext<F>) => AsyncOrSync<BodyInitFor<F>>;
type BodyInitFor<F> = Lookup<RequestInitFor<F>, 'body', unknown>;
interface EncoderContext<F> {
    readonly operationId: string;
    readonly content: ContentFormat;
    readonly headers: RequestHeaders;
    readonly options?: RequestOptions<F>;
}
interface Decoders<F extends BaseFetch> {
    readonly [mimeType: MimeType]: Decoder<F>;
}
type Decoder<F extends BaseFetch = BaseFetch> = (res: ResponseFor<F>, ctx: DecoderContext<F>) => AsyncOrSync<unknown>;
type ResponseFor<F> = F extends (url: any, init?: any) => Promise<infer R> ? R : never;
interface DecoderContext<F> {
    readonly operationId: string;
    readonly content: ContentFormat;
    readonly headers: RequestHeaders;
    readonly options?: RequestOptions<F>;
}
type Coercer<F extends BaseFetch> = (res: ResponseFor<F>, ctx: CoercerContext) => AsyncOrSync<MimeType | undefined>;
interface CoercerContext {
    readonly path: string;
    readonly method: string;
    readonly received: MimeType | undefined;
    readonly accepted: ReadonlySet<MimeType>;
    readonly declared: ReadonlyMap<MimeType, ContentFormat> | undefined;
}
type SdkFunction<F extends BaseFetch = BaseFetch> = (op: string, req: SdkRequest<F>) => Promise<SdkResponse<F>>;
interface SdkRequest<F extends BaseFetch = BaseFetch> {
    readonly headers?: RequestHeaders;
    readonly params?: unknown;
    readonly body?: unknown;
    readonly options?: RequestOptions<F>;
}
interface SdkResponse<F extends BaseFetch = BaseFetch> {
    readonly code: ResponseCode;
    readonly body?: unknown;
    readonly raw: ResponseFor<F>;
    readonly debug?: string;
}
type DA = typeof DEFAULT_ACCEPT;
type DM = typeof DEFAULT_CONTENT_TYPE;
type Input<O, F extends BaseFetch> = O extends OperationType<infer R, infer P> ? CommonInput<F> & MaybeBodyInput<Lookup<Lookup<O, 'requestBody'>, 'content'>, F> & MaybeAcceptInput<R, F> & MaybeParamInput<P> : never;
interface CommonInput<F> {
    readonly headers?: RequestHeaders;
    readonly options?: RequestOptions<F>;
}
type MaybeBodyInput<B, F extends BaseFetch> = [B] extends [undefined] ? {} : undefined extends B ? BodyInput<Exclude<B, undefined>, F> | {
    readonly body?: never;
} : BodyInput<B, F>;
type BodyInput<B, F extends BaseFetch> = DefaultBodyInput<B, F> | CustomBodyInput<B, F>;
type DefaultBodyInput<B, F extends BaseFetch> = DM extends keyof B ? {
    readonly headers?: {
        'content-type'?: DM;
    };
    readonly body: B[DM];
    readonly encoder?: Encoder<F>;
} : never;
type CustomBodyInput<B, F extends BaseFetch> = Values<{
    [K in keyof B & MimeType]: {
        readonly headers: {
            'content-type': K;
        };
        readonly body: B[K];
        readonly encoder?: Encoder<F>;
    };
}>;
type MaybeAcceptInput<R extends ResponsesType, F extends BaseFetch> = ResponseMimeTypes<R> extends never ? {} : DefaultAcceptInput<R, F> | SimpleAcceptInput<R, F> | CustomAcceptInput<R, F>;
type DefaultAcceptInput<R extends ResponsesType, F extends BaseFetch> = SplitMimeTypes<DA> & WithMimeTypeGlobs<ResponseMimeTypes<R>> extends never ? never : {
    readonly headers?: {
        readonly accept?: DA;
    };
    readonly decoder?: Decoder<F>;
};
type SimpleAcceptInput<R extends ResponsesType, F extends BaseFetch> = Values<{
    [M in WithMimeTypeGlobs<ResponseMimeTypes<R>> & string]: {
        readonly headers: {
            readonly accept: M;
        };
        readonly decoder?: Decoder<F>;
    };
}>;
type CustomAcceptInput<R extends ResponsesType, F extends BaseFetch> = Values<{
    [M in WithMimeTypeGlobs<ResponseMimeTypes<R>> & string]: {
        readonly headers: {
            readonly accept: PrefixedMimeType<M>;
        };
        readonly decoder?: Decoder<F>;
    };
}>;
type PrefixedMimeType<M extends MimeType> = `${M}${string}`;
type MaybeParamInput<P extends ParametersType> = MaybeParam<Lookup<P, 'path', {}> & Lookup<P, 'query', {}> & Lookup<P, 'headers', {}>>;
type MaybeParam<V> = keyof V extends never ? {} : {} extends V ? {
    readonly params?: V;
} : {
    readonly params: V;
};
type Output<O extends OperationType, F extends BaseFetch, X> = O extends OperationType<infer R> ? CommonOutput<F> & BodyOutput<GetHeader<X, 'accept', DA> & MimeType, R> : never;
type GetHeader<X, H extends string, D> = X extends HasHeader<H, infer V> ? V : D;
interface HasHeader<H extends string, V extends string> {
    readonly headers: {
        readonly [K in H]: V;
    };
}
interface CommonOutput<F> {
    readonly code: ResponseCode;
    readonly raw: ResponseFor<F>;
    readonly debug?: string;
}
type BodyOutput<M extends MimeType, R extends ResponsesType> = ExpectedBodyOutput<M, R> | MaybeUnknownOutput<R>;
type ExpectedBodyOutput<M extends MimeType, R extends ResponsesType> = Values<{
    [C in keyof R]: R[C] extends Has<'content', infer O> ? WithCode<C, ValuesMatchingMimeTypes<O, M>> : WithCode<C, undefined>;
}>;
type MaybeUnknownOutput<R extends ResponsesType> = 'default' extends keyof R ? never : WithCode<'default'>;
interface WithCode<C, B = unknown> {
    readonly code: C;
    readonly body: B extends never ? undefined : B;
}
type SdkFor<O extends OperationTypes<keyof O & string>, F extends BaseFetch = BaseFetch> = SdkFunction<F> & {
    readonly [K in keyof O]: SdkOperationFunction<O[K], F, Input<O[K], F>>;
};
type SdkOperationFunction<O extends OperationType, F extends BaseFetch, I extends Input<OperationType, F>> = {} extends I ? <X extends I = I>(args?: X & NeverAdditional<I, X>) => Promise<Output<O, F, Exact<I, X> extends never ? X : {}>> : <X extends I>(args: X & NeverAdditional<I, X>) => Promise<Output<O, F, X>>;
type NeverAdditional<I, X> = I extends boolean | null | number | string ? I : unknown extends I ? unknown : I extends ReadonlyArray<infer E> ? X extends ReadonlyArray<infer F> ? ReadonlyArray<NeverAdditional<E, F>> : never : {
    readonly [K in keyof X]: K extends keyof I ? NeverAdditional<I[K], NonNullable<X[K]>> : never;
};
interface components {
    schemas: {
        readonly DefinitionSourceSlice: {
            readonly index: number;
            readonly range: {
                readonly start: {
                    readonly offset: number;
                    readonly line: number;
                    readonly column: number;
                };
                readonly end: {
                    readonly offset: number;
                    readonly line: number;
                    readonly column: number;
                };
            };
            readonly definition: {
                /** @enum {string} */
                readonly category: "ALIAS" | "CONSTRAINT" | "DIMENSION" | "OBJECTIVE" | "PARAMETER" | "VARIABLE";
                readonly source: string;
                readonly label?: string;
            };
        };
        readonly ErrorSourceSlice: {
            readonly index: number;
            readonly range: {
                readonly start: components["schemas"]["SourcePosition"];
                readonly end: components["schemas"]["SourcePosition"];
            };
            readonly message: string;
            readonly code: string;
            readonly isFatal: boolean;
        };
        readonly Outline: {
            readonly dimensions: readonly {
                readonly label: string;
                readonly isNumeric: boolean;
            }[];
            readonly parameters: readonly ({
                readonly label: string;
                readonly image: {
                    readonly lowerBound: number | ("Infinity" | "-Infinity" | "Dynamic");
                    readonly upperBound: number | ("Infinity" | "-Infinity" | "Dynamic");
                    readonly isIntegral: boolean;
                };
                readonly bindings: readonly {
                    readonly dimensionLabel?: string;
                    readonly qualifier?: string;
                }[];
                readonly derivation?: {
                    /** @enum {string} */
                    readonly kind: "pinnedVariable";
                    readonly label: string;
                } | ({
                    /** @enum {string} */
                    readonly kind: "relaxedConstraintCap";
                    readonly label: string;
                    /** @enum {string} */
                    readonly variant: "deficit" | "surplus";
                });
            })[];
            readonly variables: readonly ({
                readonly label: string;
                readonly image: {
                    readonly lowerBound: number | ("Infinity" | "-Infinity" | "Dynamic");
                    readonly upperBound: components["schemas"]["TensorBound"];
                    readonly isIntegral: boolean;
                };
                readonly bindings: readonly {
                    readonly dimensionLabel?: string;
                    readonly qualifier?: string;
                }[];
                readonly derivation?: {
                    /** @enum {string} */
                    readonly kind: "relaxedConstraint";
                    readonly label: string;
                    /** @enum {string} */
                    readonly variant: "deficit" | "surplus";
                };
            })[];
            readonly constraints: readonly ({
                readonly label: string;
                /** @enum {string} */
                readonly condition: "eq" | "geq" | "leq";
                readonly bindings: readonly components["schemas"]["SourceBinding"][];
                readonly subjects: readonly ({
                    /** @enum {string} */
                    readonly kind: "parameter";
                    readonly label: string;
                } | {
                    /** @enum {string} */
                    readonly kind: "variable";
                    readonly label: string;
                })[];
                readonly derivation?: {
                    /** @enum {string} */
                    readonly kind: "pinnedVariable";
                    readonly label: string;
                } | {
                    /** @enum {string} */
                    readonly kind: "relaxedConstraintCap";
                    readonly label: string;
                    readonly variant: components["schemas"]["RelaxationSlackVariant"];
                };
            })[];
            readonly objectives: readonly {
                readonly label: string;
                readonly isMaximization: boolean;
                readonly isQuadratic: boolean;
                readonly derivation?: {
                    /** @enum {string} */
                    readonly kind: "relaxedConstraint";
                    readonly label: string;
                    readonly variant: components["schemas"]["RelaxationSlackVariant"];
                };
            }[];
        };
        readonly Transformation: ({
            /** @enum {string} */
            readonly kind: "relaxConstraint";
            readonly label: string;
            /**
             * @description Strategy for computing the cost of relaxing a constraint.
             *
             * + `TOTAL_DEVIATION`: Cost proportional to the total sum of the
             *   (absolute value of) deviation.
             * + `MAX_DEVIATION`: Cost proportional to the maximum deviation.
             * + `DEVIATION_CARDINALITY`: Cost proportional to the number of rows with
             *   non-zero deviation. This penalty requires the relaxation to be
             *   bounded with finite values.
             *
             * The default is `TOTAL_DEVIATION`.
             *
             * @enum {string}
             */
            readonly penalty?: "TOTAL_DEVIATION" | "MAX_DEVIATION" | "DEVIATION_CARDINALITY";
            /**
             * @description When set to `true`, adds deviation bound parameters
             * (`$label_deficitCap` and/or `$label_surplusCap`).
             */
            readonly isCapped?: boolean;
        }) | {
            /** @enum {string} */
            readonly kind: "omitConstraint";
            readonly label: string;
        } | {
            /** @enum {string} */
            readonly kind: "omitObjective";
            readonly label: string;
        } | {
            /** @enum {string} */
            readonly kind: "pinVariable";
            readonly label: string;
        } | {
            /** @enum {string} */
            readonly kind: "densifyVariable";
            readonly label: string;
        } | {
            /** @enum {string} */
            readonly kind: "constrainObjective";
            readonly label: string;
            readonly maxValue?: number;
            readonly minValue?: number;
        };
        readonly DimensionOutline: {
            readonly label: string;
            readonly isNumeric: boolean;
        };
        readonly ParameterOutline: {
            readonly label: string;
            readonly image: {
                readonly lowerBound: number | ("Infinity" | "-Infinity" | "Dynamic");
                readonly upperBound: components["schemas"]["TensorBound"];
                readonly isIntegral: boolean;
            };
            readonly bindings: readonly {
                readonly dimensionLabel?: string;
                readonly qualifier?: string;
            }[];
            readonly derivation?: {
                /** @enum {string} */
                readonly kind: "pinnedVariable";
                readonly label: string;
            } | ({
                /** @enum {string} */
                readonly kind: "relaxedConstraintCap";
                readonly label: string;
                /** @enum {string} */
                readonly variant: "deficit" | "surplus";
            });
        };
        readonly ParameterDerivation: {
            /** @enum {string} */
            readonly kind: "pinnedVariable";
            readonly label: string;
        } | ({
            /** @enum {string} */
            readonly kind: "relaxedConstraintCap";
            readonly label: string;
            /** @enum {string} */
            readonly variant: "deficit" | "surplus";
        });
        readonly VariableOutline: {
            readonly label: string;
            readonly image: components["schemas"]["TensorImage"];
            readonly bindings: readonly components["schemas"]["SourceBinding"][];
            readonly derivation?: {
                /** @enum {string} */
                readonly kind: "relaxedConstraint";
                readonly label: string;
                readonly variant: components["schemas"]["RelaxationSlackVariant"];
            };
        };
        readonly VariableDerivation: {
            /** @enum {string} */
            readonly kind: "relaxedConstraint";
            readonly label: string;
            readonly variant: components["schemas"]["RelaxationSlackVariant"];
        };
        /** @enum {string} */
        readonly RelaxationSlackVariant: "deficit" | "surplus";
        readonly ConstraintOutline: {
            readonly label: string;
            /** @enum {string} */
            readonly condition: "eq" | "geq" | "leq";
            readonly bindings: readonly components["schemas"]["SourceBinding"][];
            readonly subjects: readonly ({
                /** @enum {string} */
                readonly kind: "parameter";
                readonly label: string;
            } | {
                /** @enum {string} */
                readonly kind: "variable";
                readonly label: string;
            })[];
            readonly derivation?: {
                /** @enum {string} */
                readonly kind: "pinnedVariable";
                readonly label: string;
            } | {
                /** @enum {string} */
                readonly kind: "relaxedConstraintCap";
                readonly label: string;
                readonly variant: components["schemas"]["RelaxationSlackVariant"];
            };
        };
        /** @enum {string} */
        readonly ConstraintCondition: "eq" | "geq" | "leq";
        readonly ConstraintSubject: {
            /** @enum {string} */
            readonly kind: "parameter";
            readonly label: string;
        } | {
            /** @enum {string} */
            readonly kind: "variable";
            readonly label: string;
        };
        readonly ConstraintDerivation: {
            /** @enum {string} */
            readonly kind: "pinnedVariable";
            readonly label: string;
        } | {
            /** @enum {string} */
            readonly kind: "relaxedConstraintCap";
            readonly label: string;
            readonly variant: components["schemas"]["RelaxationSlackVariant"];
        };
        readonly ObjectiveOutline: {
            readonly label: string;
            readonly isMaximization: boolean;
            readonly isQuadratic: boolean;
            readonly derivation?: {
                /** @enum {string} */
                readonly kind: "relaxedConstraint";
                readonly label: string;
                readonly variant: components["schemas"]["RelaxationSlackVariant"];
            };
        };
        readonly ObjectiveDerivation: {
            /** @enum {string} */
            readonly kind: "relaxedConstraint";
            readonly label: string;
            readonly variant: components["schemas"]["RelaxationSlackVariant"];
        };
        readonly SourceBinding: {
            readonly dimensionLabel?: string;
            readonly qualifier?: string;
        };
        readonly TensorBound: number | ("Infinity" | "-Infinity" | "Dynamic");
        readonly TensorImage: {
            readonly lowerBound: number | ("Infinity" | "-Infinity" | "Dynamic");
            readonly upperBound: components["schemas"]["TensorBound"];
            readonly isIntegral: boolean;
        };
        /**
         * @description Strategy for computing the cost of relaxing a constraint.
         *
         * + `TOTAL_DEVIATION`: Cost proportional to the total sum of the
         *   (absolute value of) deviation.
         * + `MAX_DEVIATION`: Cost proportional to the maximum deviation.
         * + `DEVIATION_CARDINALITY`: Cost proportional to the number of rows with
         *   non-zero deviation. This penalty requires the relaxation to be
         *   bounded with finite values.
         *
         * The default is `TOTAL_DEVIATION`.
         *
         * @enum {string}
         */
        readonly RelaxationPenalty: "TOTAL_DEVIATION" | "MAX_DEVIATION" | "DEVIATION_CARDINALITY";
        /**
         * @description Adds slack to any constraint. The positive (resp. negative) slack will
         * be available via a variable named `$label_surplus` (resp.
         * `$label_deficit`). Objectives will also be added when applicable, named
         * `$label_minimizeSurplus` and `$label_minimizeDeficit`.
         */
        readonly RelaxConstraintTransformation: {
            /** @enum {string} */
            readonly kind: "relaxConstraint";
            readonly label: string;
            /**
             * @description Strategy for computing the cost of relaxing a constraint.
             *
             * + `TOTAL_DEVIATION`: Cost proportional to the total sum of the
             *   (absolute value of) deviation.
             * + `MAX_DEVIATION`: Cost proportional to the maximum deviation.
             * + `DEVIATION_CARDINALITY`: Cost proportional to the number of rows with
             *   non-zero deviation. This penalty requires the relaxation to be
             *   bounded with finite values.
             *
             * The default is `TOTAL_DEVIATION`.
             *
             * @enum {string}
             */
            readonly penalty?: "TOTAL_DEVIATION" | "MAX_DEVIATION" | "DEVIATION_CARDINALITY";
            /**
             * @description When set to `true`, adds deviation bound parameters
             * (`$label_deficitCap` and/or `$label_surplusCap`).
             */
            readonly isCapped?: boolean;
        };
        readonly OmitConstraintTransformation: {
            /** @enum {string} */
            readonly kind: "omitConstraint";
            readonly label: string;
        };
        readonly OmitObjectiveTransformation: {
            /** @enum {string} */
            readonly kind: "omitObjective";
            readonly label: string;
        };
        readonly PinVariableTransformation: {
            /** @enum {string} */
            readonly kind: "pinVariable";
            readonly label: string;
        };
        readonly DensifyVariableTransformation: {
            /** @enum {string} */
            readonly kind: "densifyVariable";
            readonly label: string;
        };
        readonly ConstrainObjectiveTransformation: {
            /** @enum {string} */
            readonly kind: "constrainObjective";
            readonly label: string;
            readonly maxValue?: number;
            readonly minValue?: number;
        };
        readonly Definition: {
            /** @enum {string} */
            readonly category: "ALIAS" | "CONSTRAINT" | "DIMENSION" | "OBJECTIVE" | "PARAMETER" | "VARIABLE";
            readonly source: string;
            readonly label?: string;
        };
        /** @enum {string} */
        readonly DefinitionCategory: "ALIAS" | "CONSTRAINT" | "DIMENSION" | "OBJECTIVE" | "PARAMETER" | "VARIABLE";
        readonly SourcePosition: {
            readonly offset: number;
            readonly line: number;
            readonly column: number;
        };
        readonly SourceRange: {
            readonly start: {
                readonly offset: number;
                readonly line: number;
                readonly column: number;
            };
            readonly end: components["schemas"]["SourcePosition"];
        };
        readonly Annotation: {
            readonly key: string;
            readonly value?: string;
        };
        /** @enum {string} */
        readonly AttemptOperation: "SOLVE" | "QUEUE_SOLVE" | "FORMAT_PROBLEM" | "SUMMARIZE_PROBLEM";
        /** @enum {string} */
        readonly AttemptTier: "TRYOUT" | "DEFAULT" | "PERFORMANCE";
        /** @enum {string} */
        readonly ErrorStatus: "UNKNOWN" | "INTERNAL" | "UNIMPLEMENTED" | "UNAVAILABLE" | "DEADLINE_EXCEEDED" | "ABORTED" | "INVALID_ARGUMENT" | "UNAUTHENTICATED" | "PERMISSION_DENIED" | "NOT_FOUND" | "ALREADY_EXISTS" | "FAILED_PRECONDITION" | "RESOURCE_EXHAUSTED" | "CANCELLED";
        readonly ExtendedFloat: number | ("Infinity" | "-Infinity");
        readonly Problem: {
            readonly formulation: components["schemas"]["InlineProblemFormulation"] | components["schemas"]["RemoteProblemFormulation"];
            readonly inputs: {
                readonly parameters: readonly {
                    readonly label: string;
                    /**
                     * @description Value used for entries which are not explicitly specified in the
                     * array below. Defaults to 0 when unset.
                     */
                    readonly defaultValue?: components["schemas"]["ExtendedFloat"];
                    readonly entries: readonly {
                        readonly key: readonly components["schemas"]["KeyItem"][];
                        /** @description Defaults to 1 when unset */
                        readonly value?: components["schemas"]["ExtendedFloat"];
                    }[];
                }[];
                readonly dimensions?: readonly {
                    readonly label: string;
                    readonly items: readonly components["schemas"]["KeyItem"][];
                }[];
            };
            readonly options?: components["schemas"]["SolveOptions"];
            readonly strategy?: {
                readonly isMaximization: boolean;
                readonly target: components["schemas"]["WeightedSumTarget"];
                readonly epsilonConstraints?: readonly {
                    readonly target: components["schemas"]["WeightedSumTarget"];
                    readonly absoluteTolerance?: number;
                    readonly relativeTolerance?: number;
                    [key: string]: unknown;
                }[];
                [key: string]: unknown;
            };
            readonly transformations?: readonly (({
                /** @enum {string} */
                readonly kind: "relaxConstraint";
                readonly label: string;
                /**
                 * @description Strategy for computing the cost of relaxing a constraint.
                 *
                 * + `TOTAL_DEVIATION`: Cost proportional to the total sum of the
                 *   (absolute value of) deviation.
                 * + `MAX_DEVIATION`: Cost proportional to the maximum deviation.
                 * + `DEVIATION_CARDINALITY`: Cost proportional to the number of rows with
                 *   non-zero deviation. This penalty requires the relaxation to be
                 *   bounded with finite values.
                 *
                 * The default is `TOTAL_DEVIATION`.
                 *
                 * @enum {string}
                 */
                readonly penalty?: "TOTAL_DEVIATION" | "MAX_DEVIATION" | "DEVIATION_CARDINALITY";
                /**
                 * @description When set to `true`, adds deviation bound parameters
                 * (`$label_deficitCap` and/or `$label_surplusCap`).
                 */
                readonly isCapped?: boolean;
            }) | {
                /** @enum {string} */
                readonly kind: "omitConstraint";
                readonly label: string;
            } | {
                /** @enum {string} */
                readonly kind: "omitObjective";
                readonly label: string;
            } | {
                /** @enum {string} */
                readonly kind: "pinVariable";
                readonly label: string;
            } | {
                /** @enum {string} */
                readonly kind: "densifyVariable";
                readonly label: string;
            } | {
                /** @enum {string} */
                readonly kind: "constrainObjective";
                readonly label: string;
                readonly maxValue?: number;
                readonly minValue?: number;
            })[];
        };
        /** @enum {string} */
        readonly ProblemSize: "XS" | "SM" | "MD" | "LG" | "XL";
        readonly SolveInputs: {
            readonly parameters: readonly {
                readonly label: string;
                /**
                 * @description Value used for entries which are not explicitly specified in the
                 * array below. Defaults to 0 when unset.
                 */
                readonly defaultValue?: components["schemas"]["ExtendedFloat"];
                readonly entries: readonly {
                    readonly key: readonly components["schemas"]["KeyItem"][];
                    /** @description Defaults to 1 when unset */
                    readonly value?: components["schemas"]["ExtendedFloat"];
                }[];
            }[];
            readonly dimensions?: readonly {
                readonly label: string;
                readonly items: readonly components["schemas"]["KeyItem"][];
            }[];
        };
        readonly SolveStrategy: {
            readonly isMaximization: boolean;
            readonly target: components["schemas"]["WeightedSumTarget"];
            readonly epsilonConstraints?: readonly {
                readonly target: components["schemas"]["WeightedSumTarget"];
                readonly absoluteTolerance?: number;
                readonly relativeTolerance?: number;
                [key: string]: unknown;
            }[];
            [key: string]: unknown;
        };
        readonly SolveOptions: {
            /** @description Relative gap threshold at which to consider a solution optimal */
            readonly relativeGapThreshold?: number;
            /** @description Absolute gap threshold at which to consider a solution optimal */
            readonly absoluteGapThreshold?: number;
            /**
             * @description Upper bound on solving time. Note that the overall attempt time may
             * be greater due to processing outside of the solve itself.
             */
            readonly timeoutMillis?: number;
            /**
             * @description Positive magnitude below which values will be assumed equal to
             * zero. This is also used on solution results, causing values to be
             * omitted from the solution if their dual value is also absent. It is
             * finally used as threshold for rounding integral variables to the
             * nearest integer. The default is 1e-6.
             */
            readonly zeroValueThreshold?: number;
            /**
             * @description Positive magnitude used to cap all input values. It is illegal for
             * the reified problem to include coefficients higher or equal to this
             * value so the input needs to be such that they are masked out during
             * reification. The default is 1e13.
             */
            readonly infinityValueThreshold?: number;
            /**
             * @description Positive magnitude used to decide whether a bound is free. This
             * value should typically be slightly smaller to the infinity value
             * threshold to allow for small offsets to infinite values. The
             * default is 1e12.
             */
            readonly freeBoundThreshold?: number;
        };
        readonly SolveOutcome: {
            readonly status: components["schemas"]["SolveStatus"];
            readonly objectiveValue?: number;
            readonly relativeGap?: components["schemas"]["ExtendedFloat"];
            [key: string]: unknown;
        };
        readonly SolveOutputs: {
            /**
             * @description All entries where the constraint is active. Unlike for variables,
             * zero-valued entries are included as they represent tight
             * constraints.
             */
            readonly constraints: readonly {
                readonly label: string;
                readonly entries: readonly {
                    readonly key: readonly components["schemas"]["KeyItem"][];
                    readonly value: number;
                    readonly dualValue?: number;
                }[];
            }[];
            /** @description Entries with zero primal value and null dual value are omitted. */
            readonly variables: readonly {
                readonly label: string;
                readonly entries: readonly {
                    readonly key: readonly components["schemas"]["KeyItem"][];
                    readonly value: number;
                    readonly dualValue?: number;
                }[];
            }[];
        };
        readonly SolveUpdate: ({
            /** @enum {string} */
            readonly kind: "reifying";
            readonly progress: {
                /** @enum {string} */
                readonly kind: "constraint";
                readonly summary: {
                    readonly label: string;
                    readonly domainMultiplicity: string;
                    readonly coefficientMultiplicity: string;
                    readonly rowCount: number;
                    readonly columnCount: number;
                    readonly weightProfile: {
                        readonly count: number;
                        readonly min?: components["schemas"]["ExtendedFloat"];
                        readonly max?: components["schemas"]["ExtendedFloat"];
                        readonly mean?: number;
                        readonly stddev?: number;
                        readonly buckets: readonly {
                            readonly left: components["schemas"]["ExtendedFloat"];
                            readonly right: components["schemas"]["ExtendedFloat"];
                            readonly count: number;
                        }[];
                    };
                    readonly reifiedInMillis: number;
                };
            } | {
                /** @enum {string} */
                readonly kind: "objective";
                readonly summary: {
                    readonly label: string;
                    readonly coefficientMultiplicity: string;
                    readonly weightProfile: {
                        readonly count: number;
                        readonly min?: components["schemas"]["ExtendedFloat"];
                        readonly max?: components["schemas"]["ExtendedFloat"];
                        readonly mean?: number;
                        readonly stddev?: number;
                        readonly buckets: readonly {
                            readonly left: components["schemas"]["ExtendedFloat"];
                            readonly right: components["schemas"]["ExtendedFloat"];
                            readonly count: number;
                        }[];
                    };
                    readonly reifiedInMillis: number;
                };
            };
        }) | {
            /** @enum {string} */
            readonly kind: "reified";
            readonly summary: {
                readonly dimensions: readonly components["schemas"]["ProblemDimensionSummary"][];
                readonly parameters: readonly {
                    readonly label: string;
                    readonly domainMultiplicity: string;
                    readonly entryProfile: {
                        readonly count: number;
                        readonly min?: components["schemas"]["ExtendedFloat"];
                        readonly max?: components["schemas"]["ExtendedFloat"];
                        readonly mean?: number;
                        readonly stddev?: number;
                        readonly buckets: readonly {
                            readonly left: components["schemas"]["ExtendedFloat"];
                            readonly right: components["schemas"]["ExtendedFloat"];
                            readonly count: number;
                        }[];
                    };
                }[];
                readonly constraints: readonly {
                    readonly label: string;
                    readonly domainMultiplicity: string;
                    readonly coefficientMultiplicity: string;
                    readonly rowCount: number;
                    readonly columnCount: number;
                    readonly weightProfile: {
                        readonly count: number;
                        readonly min?: components["schemas"]["ExtendedFloat"];
                        readonly max?: components["schemas"]["ExtendedFloat"];
                        readonly mean?: number;
                        readonly stddev?: number;
                        readonly buckets: readonly {
                            readonly left: components["schemas"]["ExtendedFloat"];
                            readonly right: components["schemas"]["ExtendedFloat"];
                            readonly count: number;
                        }[];
                    };
                    readonly reifiedInMillis: number;
                }[];
                readonly variables: readonly components["schemas"]["ProblemVariableSummary"][];
                readonly objectives: readonly {
                    readonly label: string;
                    readonly coefficientMultiplicity: string;
                    readonly weightProfile: {
                        readonly count: number;
                        readonly min?: components["schemas"]["ExtendedFloat"];
                        readonly max?: components["schemas"]["ExtendedFloat"];
                        readonly mean?: number;
                        readonly stddev?: number;
                        readonly buckets: readonly {
                            readonly left: components["schemas"]["ExtendedFloat"];
                            readonly right: components["schemas"]["ExtendedFloat"];
                            readonly count: number;
                        }[];
                    };
                    readonly reifiedInMillis: number;
                }[];
            };
        } | ({
            /** @enum {string} */
            readonly kind: "solving";
            readonly progress: {
                /** @enum {string} */
                readonly kind: "activity";
                readonly relativeGap?: components["schemas"]["ExtendedFloat"];
                readonly cutCount?: number;
                readonly lpIterationCount?: number;
            } | {
                /** @enum {string} */
                readonly kind: "epsilonConstraint";
                readonly objectiveValue: number;
            };
        }) | {
            /** @enum {string} */
            readonly kind: "denormalized";
            readonly summary: {
                readonly variables: readonly {
                    readonly label: string;
                    readonly resultProfile: {
                        readonly count: number;
                        readonly min?: components["schemas"]["ExtendedFloat"];
                        readonly max?: components["schemas"]["ExtendedFloat"];
                        readonly mean?: number;
                        readonly stddev?: number;
                        readonly buckets: readonly {
                            readonly left: components["schemas"]["ExtendedFloat"];
                            readonly right: components["schemas"]["ExtendedFloat"];
                            readonly count: number;
                        }[];
                    };
                }[];
            };
        } | {
            /** @enum {string} */
            readonly kind: "solved";
            readonly outcome: {
                readonly status: components["schemas"]["SolveStatus"];
                readonly objectiveValue?: number;
                readonly relativeGap?: components["schemas"]["ExtendedFloat"];
                [key: string]: unknown;
            };
            readonly outputs?: {
                /**
                 * @description All entries where the constraint is active. Unlike for variables,
                 * zero-valued entries are included as they represent tight
                 * constraints.
                 */
                readonly constraints: readonly {
                    readonly label: string;
                    readonly entries: readonly {
                        readonly key: readonly components["schemas"]["KeyItem"][];
                        readonly value: number;
                        readonly dualValue?: number;
                    }[];
                }[];
                /** @description Entries with zero primal value and null dual value are omitted. */
                readonly variables: readonly {
                    readonly label: string;
                    readonly entries: readonly {
                        readonly key: readonly components["schemas"]["KeyItem"][];
                        readonly value: number;
                        readonly dualValue?: number;
                    }[];
                }[];
            };
        } | {
            /** @enum {string} */
            readonly kind: "error";
            readonly status: string;
            readonly error: {
                readonly message: string;
                readonly code?: string;
                readonly tags?: {
                    [key: string]: unknown;
                };
            };
        };
        readonly ReifyProgress: {
            /** @enum {string} */
            readonly kind: "constraint";
            readonly summary: {
                readonly label: string;
                readonly domainMultiplicity: string;
                readonly coefficientMultiplicity: string;
                readonly rowCount: number;
                readonly columnCount: number;
                readonly weightProfile: {
                    readonly count: number;
                    readonly min?: components["schemas"]["ExtendedFloat"];
                    readonly max?: components["schemas"]["ExtendedFloat"];
                    readonly mean?: number;
                    readonly stddev?: number;
                    readonly buckets: readonly {
                        readonly left: components["schemas"]["ExtendedFloat"];
                        readonly right: components["schemas"]["ExtendedFloat"];
                        readonly count: number;
                    }[];
                };
                readonly reifiedInMillis: number;
            };
        } | {
            /** @enum {string} */
            readonly kind: "objective";
            readonly summary: {
                readonly label: string;
                readonly coefficientMultiplicity: string;
                readonly weightProfile: {
                    readonly count: number;
                    readonly min?: components["schemas"]["ExtendedFloat"];
                    readonly max?: components["schemas"]["ExtendedFloat"];
                    readonly mean?: number;
                    readonly stddev?: number;
                    readonly buckets: readonly {
                        readonly left: components["schemas"]["ExtendedFloat"];
                        readonly right: components["schemas"]["ExtendedFloat"];
                        readonly count: number;
                    }[];
                };
                readonly reifiedInMillis: number;
            };
        };
        readonly SolveProgress: {
            /** @enum {string} */
            readonly kind: "activity";
            readonly relativeGap?: components["schemas"]["ExtendedFloat"];
            readonly cutCount?: number;
            readonly lpIterationCount?: number;
        } | {
            /** @enum {string} */
            readonly kind: "epsilonConstraint";
            readonly objectiveValue: number;
        };
        readonly SolveSummaries: {
            readonly problem: {
                readonly dimensions: readonly components["schemas"]["ProblemDimensionSummary"][];
                readonly parameters: readonly {
                    readonly label: string;
                    readonly domainMultiplicity: string;
                    readonly entryProfile: {
                        readonly count: number;
                        readonly min?: components["schemas"]["ExtendedFloat"];
                        readonly max?: components["schemas"]["ExtendedFloat"];
                        readonly mean?: number;
                        readonly stddev?: number;
                        readonly buckets: readonly {
                            readonly left: components["schemas"]["ExtendedFloat"];
                            readonly right: components["schemas"]["ExtendedFloat"];
                            readonly count: number;
                        }[];
                    };
                }[];
                readonly constraints: readonly {
                    readonly label: string;
                    readonly domainMultiplicity: string;
                    readonly coefficientMultiplicity: string;
                    readonly rowCount: number;
                    readonly columnCount: number;
                    readonly weightProfile: {
                        readonly count: number;
                        readonly min?: components["schemas"]["ExtendedFloat"];
                        readonly max?: components["schemas"]["ExtendedFloat"];
                        readonly mean?: number;
                        readonly stddev?: number;
                        readonly buckets: readonly {
                            readonly left: components["schemas"]["ExtendedFloat"];
                            readonly right: components["schemas"]["ExtendedFloat"];
                            readonly count: number;
                        }[];
                    };
                    readonly reifiedInMillis: number;
                }[];
                readonly variables: readonly components["schemas"]["ProblemVariableSummary"][];
                readonly objectives: readonly {
                    readonly label: string;
                    readonly coefficientMultiplicity: string;
                    readonly weightProfile: {
                        readonly count: number;
                        readonly min?: components["schemas"]["ExtendedFloat"];
                        readonly max?: components["schemas"]["ExtendedFloat"];
                        readonly mean?: number;
                        readonly stddev?: number;
                        readonly buckets: readonly {
                            readonly left: components["schemas"]["ExtendedFloat"];
                            readonly right: components["schemas"]["ExtendedFloat"];
                            readonly count: number;
                        }[];
                    };
                    readonly reifiedInMillis: number;
                }[];
            };
            readonly solution?: {
                readonly variables: readonly {
                    readonly label: string;
                    readonly resultProfile: {
                        readonly count: number;
                        readonly min?: components["schemas"]["ExtendedFloat"];
                        readonly max?: components["schemas"]["ExtendedFloat"];
                        readonly mean?: number;
                        readonly stddev?: number;
                        readonly buckets: readonly {
                            readonly left: components["schemas"]["ExtendedFloat"];
                            readonly right: components["schemas"]["ExtendedFloat"];
                            readonly count: number;
                        }[];
                    };
                }[];
            };
        };
        readonly Failure: {
            /** @enum {string} */
            readonly status: "UNKNOWN" | "INTERNAL" | "UNIMPLEMENTED" | "UNAVAILABLE" | "DEADLINE_EXCEEDED" | "ABORTED" | "INVALID_ARGUMENT" | "UNAUTHENTICATED" | "PERMISSION_DENIED" | "NOT_FOUND" | "ALREADY_EXISTS" | "FAILED_PRECONDITION" | "RESOURCE_EXHAUSTED" | "CANCELLED";
            readonly error: {
                readonly message: string;
                readonly code?: string;
                readonly tags?: {
                    [key: string]: unknown;
                };
            };
        };
        /** @enum {string} */
        readonly SolveStatus: "UNKNOWN" | "INFEASIBLE" | "UNBOUNDED" | "FEASIBLE" | "OPTIMAL" | "ABORTED";
        readonly TensorResult: {
            readonly label: string;
            readonly entries: readonly {
                readonly key: readonly components["schemas"]["KeyItem"][];
                readonly value: number;
                readonly dualValue?: number;
            }[];
        };
        readonly TensorResultEntry: {
            readonly key: readonly components["schemas"]["KeyItem"][];
            readonly value: number;
            readonly dualValue?: number;
        };
        readonly InlineProblemFormulation: {
            readonly sources: readonly string[];
        };
        readonly RemoteProblemFormulation: {
            readonly name: string;
            readonly specificationTagName?: string;
        };
        readonly Transformations: readonly (({
            /** @enum {string} */
            readonly kind: "relaxConstraint";
            readonly label: string;
            /**
             * @description Strategy for computing the cost of relaxing a constraint.
             *
             * + `TOTAL_DEVIATION`: Cost proportional to the total sum of the
             *   (absolute value of) deviation.
             * + `MAX_DEVIATION`: Cost proportional to the maximum deviation.
             * + `DEVIATION_CARDINALITY`: Cost proportional to the number of rows with
             *   non-zero deviation. This penalty requires the relaxation to be
             *   bounded with finite values.
             *
             * The default is `TOTAL_DEVIATION`.
             *
             * @enum {string}
             */
            readonly penalty?: "TOTAL_DEVIATION" | "MAX_DEVIATION" | "DEVIATION_CARDINALITY";
            /**
             * @description When set to `true`, adds deviation bound parameters
             * (`$label_deficitCap` and/or `$label_surplusCap`).
             */
            readonly isCapped?: boolean;
        }) | {
            /** @enum {string} */
            readonly kind: "omitConstraint";
            readonly label: string;
        } | {
            /** @enum {string} */
            readonly kind: "omitObjective";
            readonly label: string;
        } | {
            /** @enum {string} */
            readonly kind: "pinVariable";
            readonly label: string;
        } | {
            /** @enum {string} */
            readonly kind: "densifyVariable";
            readonly label: string;
        } | {
            /** @enum {string} */
            readonly kind: "constrainObjective";
            readonly label: string;
            readonly maxValue?: number;
            readonly minValue?: number;
        })[];
        readonly EntryKey: readonly components["schemas"]["KeyItem"][];
        readonly KeyItem: number | string;
        readonly KeyItemSet: {
            readonly label: string;
            readonly items: readonly components["schemas"]["KeyItem"][];
        };
        readonly Tensor: {
            readonly label: string;
            /**
             * @description Value used for entries which are not explicitly specified in the
             * array below. Defaults to 0 when unset.
             */
            readonly defaultValue?: components["schemas"]["ExtendedFloat"];
            readonly entries: readonly {
                readonly key: readonly components["schemas"]["KeyItem"][];
                /** @description Defaults to 1 when unset */
                readonly value?: components["schemas"]["ExtendedFloat"];
            }[];
        };
        readonly TensorEntry: {
            readonly key: readonly components["schemas"]["KeyItem"][];
            /** @description Defaults to 1 when unset */
            readonly value?: components["schemas"]["ExtendedFloat"];
        };
        readonly WeightedSumTarget: {
            readonly weights: readonly {
                readonly label: string;
                readonly value: number;
                [key: string]: unknown;
            }[];
            [key: string]: unknown;
        };
        readonly ProblemSummary: {
            readonly dimensions: readonly {
                readonly label: string;
                readonly itemCount: number;
            }[];
            readonly parameters: readonly {
                readonly label: string;
                readonly domainMultiplicity: string;
                readonly entryProfile: {
                    readonly count: number;
                    readonly min?: components["schemas"]["ExtendedFloat"];
                    readonly max?: components["schemas"]["ExtendedFloat"];
                    readonly mean?: number;
                    readonly stddev?: number;
                    readonly buckets: readonly {
                        readonly left: components["schemas"]["ExtendedFloat"];
                        readonly right: components["schemas"]["ExtendedFloat"];
                        readonly count: number;
                    }[];
                };
            }[];
            readonly constraints: readonly {
                readonly label: string;
                readonly domainMultiplicity: string;
                readonly coefficientMultiplicity: string;
                readonly rowCount: number;
                readonly columnCount: number;
                readonly weightProfile: components["schemas"]["ValueProfile"];
                readonly reifiedInMillis: number;
            }[];
            readonly variables: readonly {
                readonly label: string;
                readonly domainMultiplicity: string;
                readonly columnCount: number;
            }[];
            readonly objectives: readonly {
                readonly label: string;
                readonly coefficientMultiplicity: string;
                readonly weightProfile: components["schemas"]["ValueProfile"];
                readonly reifiedInMillis: number;
            }[];
        };
        readonly ProblemConstraintSummary: {
            readonly label: string;
            readonly domainMultiplicity: string;
            readonly coefficientMultiplicity: string;
            readonly rowCount: number;
            readonly columnCount: number;
            readonly weightProfile: components["schemas"]["ValueProfile"];
            readonly reifiedInMillis: number;
        };
        readonly ProblemDimensionSummary: {
            readonly label: string;
            readonly itemCount: number;
        };
        readonly ProblemObjectiveSummary: {
            readonly label: string;
            readonly coefficientMultiplicity: string;
            readonly weightProfile: components["schemas"]["ValueProfile"];
            readonly reifiedInMillis: number;
        };
        readonly ProblemParameterSummary: {
            readonly label: string;
            readonly domainMultiplicity: string;
            readonly entryProfile: {
                readonly count: number;
                readonly min?: components["schemas"]["ExtendedFloat"];
                readonly max?: components["schemas"]["ExtendedFloat"];
                readonly mean?: number;
                readonly stddev?: number;
                readonly buckets: readonly {
                    readonly left: components["schemas"]["ExtendedFloat"];
                    readonly right: components["schemas"]["ExtendedFloat"];
                    readonly count: number;
                }[];
            };
        };
        readonly ProblemVariableSummary: {
            readonly label: string;
            readonly domainMultiplicity: string;
            readonly columnCount: number;
        };
        readonly SolutionSummary: {
            readonly variables: readonly {
                readonly label: string;
                readonly resultProfile: components["schemas"]["ValueProfile"];
            }[];
        };
        readonly SolutionVariableSummary: {
            readonly label: string;
            readonly resultProfile: components["schemas"]["ValueProfile"];
        };
        readonly ValueProfile: {
            readonly count: number;
            readonly min?: components["schemas"]["ExtendedFloat"];
            readonly max?: components["schemas"]["ExtendedFloat"];
            readonly mean?: number;
            readonly stddev?: number;
            readonly buckets: readonly {
                readonly left: components["schemas"]["ExtendedFloat"];
                readonly right: components["schemas"]["ExtendedFloat"];
                readonly count: number;
            }[];
        };
        readonly ValueProfileBucket: {
            readonly left: components["schemas"]["ExtendedFloat"];
            readonly right: components["schemas"]["ExtendedFloat"];
            readonly count: number;
        };
        readonly ProblemMeasurements: {
            readonly itemCount?: number;
            readonly entryCount?: number;
            readonly rowCount?: number;
            readonly columnCount?: number;
            readonly weightCount?: number;
        };
    };
    responses: {
        /** @description Generic error */
        readonly Error: {
            content: {
                readonly "application/json": {
                    /** @enum {string} */
                    readonly status: "UNKNOWN" | "INTERNAL" | "UNIMPLEMENTED" | "UNAVAILABLE" | "DEADLINE_EXCEEDED" | "ABORTED" | "INVALID_ARGUMENT" | "UNAUTHENTICATED" | "PERMISSION_DENIED" | "NOT_FOUND" | "ALREADY_EXISTS" | "FAILED_PRECONDITION" | "RESOURCE_EXHAUSTED" | "CANCELLED";
                    readonly error: {
                        readonly message: string;
                        readonly code?: string;
                        readonly tags?: {
                            [key: string]: unknown;
                        };
                    };
                };
                readonly "text/plain": string;
            };
        };
        /** @description Generic error */
        readonly Error1: {
            content: {
                readonly "application/json": {
                    /** @enum {string} */
                    readonly status: "UNKNOWN" | "INTERNAL" | "UNIMPLEMENTED" | "UNAVAILABLE" | "DEADLINE_EXCEEDED" | "ABORTED" | "INVALID_ARGUMENT" | "UNAUTHENTICATED" | "PERMISSION_DENIED" | "NOT_FOUND" | "ALREADY_EXISTS" | "FAILED_PRECONDITION" | "RESOURCE_EXHAUSTED" | "CANCELLED";
                    readonly error: {
                        readonly message: string;
                        readonly code?: string;
                        readonly tags?: {
                            [key: string]: unknown;
                        };
                    };
                };
                readonly "text/plain": string;
            };
        };
        /** @description Generic error response */
        readonly Error2: {
            content: {
                readonly "application/json": {
                    /** @enum {string} */
                    readonly status: "UNKNOWN" | "INTERNAL" | "UNIMPLEMENTED" | "UNAVAILABLE" | "DEADLINE_EXCEEDED" | "ABORTED" | "INVALID_ARGUMENT" | "UNAUTHENTICATED" | "PERMISSION_DENIED" | "NOT_FOUND" | "ALREADY_EXISTS" | "FAILED_PRECONDITION" | "RESOURCE_EXHAUSTED" | "CANCELLED";
                    readonly error: {
                        readonly message: string;
                        readonly code?: string;
                        readonly tags?: {
                            [key: string]: unknown;
                        };
                    };
                };
                readonly "text/plain": string;
            };
        };
    };
    parameters: {
        readonly QueuedSolveUuid: string;
    };
    requestBodies: {
        readonly QueueSolveRequest: {
            readonly content: {
                readonly "application/json": {
                    readonly annotations?: readonly {
                        readonly key: string;
                        readonly value?: string;
                    }[];
                    readonly problem: {
                        readonly formulation: components["schemas"]["InlineProblemFormulation"] | components["schemas"]["RemoteProblemFormulation"];
                        readonly inputs: {
                            readonly parameters: readonly {
                                readonly label: string;
                                /**
                                 * @description Value used for entries which are not explicitly specified in the
                                 * array below. Defaults to 0 when unset.
                                 */
                                readonly defaultValue?: components["schemas"]["ExtendedFloat"];
                                readonly entries: readonly {
                                    readonly key: readonly components["schemas"]["KeyItem"][];
                                    /** @description Defaults to 1 when unset */
                                    readonly value?: components["schemas"]["ExtendedFloat"];
                                }[];
                            }[];
                            readonly dimensions?: readonly {
                                readonly label: string;
                                readonly items: readonly components["schemas"]["KeyItem"][];
                            }[];
                        };
                        readonly options?: components["schemas"]["SolveOptions"];
                        readonly strategy?: {
                            readonly isMaximization: boolean;
                            readonly target: components["schemas"]["WeightedSumTarget"];
                            readonly epsilonConstraints?: readonly {
                                readonly target: components["schemas"]["WeightedSumTarget"];
                                readonly absoluteTolerance?: number;
                                readonly relativeTolerance?: number;
                                [key: string]: unknown;
                            }[];
                            [key: string]: unknown;
                        };
                        readonly transformations?: readonly (({
                            /** @enum {string} */
                            readonly kind: "relaxConstraint";
                            readonly label: string;
                            /**
                             * @description Strategy for computing the cost of relaxing a constraint.
                             *
                             * + `TOTAL_DEVIATION`: Cost proportional to the total sum of the
                             *   (absolute value of) deviation.
                             * + `MAX_DEVIATION`: Cost proportional to the maximum deviation.
                             * + `DEVIATION_CARDINALITY`: Cost proportional to the number of rows with
                             *   non-zero deviation. This penalty requires the relaxation to be
                             *   bounded with finite values.
                             *
                             * The default is `TOTAL_DEVIATION`.
                             *
                             * @enum {string}
                             */
                            readonly penalty?: "TOTAL_DEVIATION" | "MAX_DEVIATION" | "DEVIATION_CARDINALITY";
                            /**
                             * @description When set to `true`, adds deviation bound parameters
                             * (`$label_deficitCap` and/or `$label_surplusCap`).
                             */
                            readonly isCapped?: boolean;
                        }) | {
                            /** @enum {string} */
                            readonly kind: "omitConstraint";
                            readonly label: string;
                        } | {
                            /** @enum {string} */
                            readonly kind: "omitObjective";
                            readonly label: string;
                        } | {
                            /** @enum {string} */
                            readonly kind: "pinVariable";
                            readonly label: string;
                        } | {
                            /** @enum {string} */
                            readonly kind: "densifyVariable";
                            readonly label: string;
                        } | {
                            /** @enum {string} */
                            readonly kind: "constrainObjective";
                            readonly label: string;
                            readonly maxValue?: number;
                            readonly minValue?: number;
                        })[];
                    };
                    [key: string]: unknown;
                };
            };
        };
    };
    headers: never;
    pathItems: never;
}
interface operations {
    /** @description Fetch OpenAPI schema */
    getOpenapiSchema: {
        responses: {
            /** @description OpenAPI schema */
            200: {
                content: {
                    readonly "text/yaml": string;
                };
            };
        };
    };
    /** @description Fetch OpenAPI named component schema */
    getOpenapiComponentSchema: {
        parameters: {
            query: {
                name: string;
            };
        };
        responses: {
            /** @description JSONSchema for the requested component */
            200: {
                content: {
                    readonly "application/json": {
                        [key: string]: unknown;
                    };
                };
            };
            /** @description No component schema for this name */
            404: {
                content: never;
            };
        };
    };
    /** @description Fetch GraphQL schema */
    getGraphqlSchema: {
        responses: {
            /** @description GraphQL schema */
            200: {
                content: {
                    readonly "text/graphql": string;
                };
            };
        };
    };
    /** @description GraphQL endpoint */
    runQuery: {
        readonly requestBody: {
            readonly content: {
                readonly "application/json": {
                    readonly query: string;
                    readonly variables?: {
                        [key: string]: unknown;
                    };
                };
            };
        };
        responses: {
            /** @description Expected response */
            200: {
                content: {
                    readonly "application/json": {
                        readonly data?: ((readonly unknown[]) | boolean | number | {
                            [key: string]: unknown;
                        } | string) | null;
                        readonly errors?: (readonly ({
                            readonly message: string;
                            readonly locations?: readonly {
                                readonly line: number;
                                readonly column: number;
                            }[];
                            readonly path?: readonly (number | string)[];
                            readonly extensions?: {
                                [key: string]: unknown;
                            };
                        })[]) | null;
                        readonly extensions?: {
                            [key: string]: unknown;
                        };
                        [key: string]: unknown;
                    };
                };
            };
            /** @description Unexpected error */
            default: {
                content: {
                    readonly "application/json": {
                        /** @enum {string} */
                        readonly status: "UNKNOWN" | "INTERNAL" | "UNIMPLEMENTED" | "UNAVAILABLE" | "DEADLINE_EXCEEDED" | "ABORTED" | "INVALID_ARGUMENT" | "UNAUTHENTICATED" | "PERMISSION_DENIED" | "NOT_FOUND" | "ALREADY_EXISTS" | "FAILED_PRECONDITION" | "RESOURCE_EXHAUSTED" | "CANCELLED";
                        readonly error: {
                            readonly message: string;
                            readonly code?: string;
                            readonly tags?: {
                                [key: string]: unknown;
                            };
                        };
                    };
                    readonly "text/plain": string;
                };
            };
        };
    };
    /** @description Applies transformations to an outline */
    transformOutline: {
        readonly requestBody: {
            readonly content: {
                readonly "application/json": {
                    readonly outline: components["schemas"]["Outline"];
                    readonly transformations: readonly components["schemas"]["Transformation"][];
                };
            };
        };
        responses: {
            /** @description Transformed outline */
            200: {
                content: {
                    readonly "application/json": {
                        readonly outline: components["schemas"]["Outline"];
                    };
                };
            };
            default: components["responses"]["Error1"];
        };
    };
    /** @description Assembles a model's formulation */
    assembleSources: {
        readonly requestBody: {
            readonly content: {
                readonly "application/json": {
                    readonly sources: readonly string[];
                    readonly transformations?: readonly components["schemas"]["Transformation"][];
                };
            };
        };
        responses: {
            /** @description Successful assembly output */
            200: {
                content: {
                    readonly "application/octet-stream": Blob;
                };
            };
            default: components["responses"]["Error1"];
        };
    };
    /** @description Parses and validates a model's formulation */
    parseSources: {
        readonly requestBody: {
            readonly content: {
                readonly "application/json": {
                    readonly sources: readonly string[];
                    readonly outline?: boolean;
                };
            };
        };
        responses: {
            /** @description Successful parse output */
            200: {
                content: {
                    readonly "application/json": {
                        readonly slices: readonly components["schemas"]["DefinitionSourceSlice"][];
                        readonly errors: readonly components["schemas"]["ErrorSourceSlice"][];
                        readonly outline?: components["schemas"]["Outline"];
                    };
                };
            };
            default: components["responses"]["Error1"];
        };
    };
    /** @description Solve an optimization problem synchronously */
    solve: {
        readonly requestBody: {
            readonly content: {
                readonly "application/json": {
                    readonly problem: {
                        readonly formulation: components["schemas"]["InlineProblemFormulation"] | components["schemas"]["RemoteProblemFormulation"];
                        readonly inputs: {
                            readonly parameters: readonly ({
                                readonly label: string;
                                /**
                                 * @description Value used for entries which are not explicitly specified in the
                                 * array below. Defaults to 0 when unset.
                                 */
                                readonly defaultValue?: number | ("Infinity" | "-Infinity");
                                readonly entries: readonly ({
                                    readonly key: readonly (number | string)[];
                                    /** @description Defaults to 1 when unset */
                                    readonly value?: components["schemas"]["ExtendedFloat"];
                                })[];
                            })[];
                            readonly dimensions?: readonly {
                                readonly label: string;
                                readonly items: readonly components["schemas"]["KeyItem"][];
                            }[];
                        };
                        readonly options?: components["schemas"]["SolveOptions"];
                        readonly strategy?: {
                            readonly isMaximization: boolean;
                            readonly target: components["schemas"]["WeightedSumTarget"];
                            readonly epsilonConstraints?: readonly {
                                readonly target: components["schemas"]["WeightedSumTarget"];
                                readonly absoluteTolerance?: number;
                                readonly relativeTolerance?: number;
                                [key: string]: unknown;
                            }[];
                            [key: string]: unknown;
                        };
                        readonly transformations?: readonly (({
                            /** @enum {string} */
                            readonly kind: "relaxConstraint";
                            readonly label: string;
                            /**
                             * @description Strategy for computing the cost of relaxing a constraint.
                             *
                             * + `TOTAL_DEVIATION`: Cost proportional to the total sum of the
                             *   (absolute value of) deviation.
                             * + `MAX_DEVIATION`: Cost proportional to the maximum deviation.
                             * + `DEVIATION_CARDINALITY`: Cost proportional to the number of rows with
                             *   non-zero deviation. This penalty requires the relaxation to be
                             *   bounded with finite values.
                             *
                             * The default is `TOTAL_DEVIATION`.
                             *
                             * @enum {string}
                             */
                            readonly penalty?: "TOTAL_DEVIATION" | "MAX_DEVIATION" | "DEVIATION_CARDINALITY";
                            /**
                             * @description When set to `true`, adds deviation bound parameters
                             * (`$label_deficitCap` and/or `$label_surplusCap`).
                             */
                            readonly isCapped?: boolean;
                        }) | {
                            /** @enum {string} */
                            readonly kind: "omitConstraint";
                            readonly label: string;
                        } | {
                            /** @enum {string} */
                            readonly kind: "omitObjective";
                            readonly label: string;
                        } | {
                            /** @enum {string} */
                            readonly kind: "pinVariable";
                            readonly label: string;
                        } | {
                            /** @enum {string} */
                            readonly kind: "densifyVariable";
                            readonly label: string;
                        } | {
                            /** @enum {string} */
                            readonly kind: "constrainObjective";
                            readonly label: string;
                            readonly maxValue?: number;
                            readonly minValue?: number;
                        })[];
                    };
                };
            };
        };
        responses: {
            /**
             * @description Solve response. When possible, consider using the `application/json-seq` content-type to receive streamed information as the solve progresses.
             * * Non-incremental information, via `application/json`. The payload
             *   is sent after the solve completes.
             * * Incremental information about the solve, via
             *   `application/json-seq`. Messages will be streamed as the solve
             *   progresses.
             */
            200: {
                content: {
                    readonly "application/json": {
                        readonly summaries: {
                            readonly problem: {
                                readonly dimensions: readonly components["schemas"]["ProblemDimensionSummary"][];
                                readonly parameters: readonly {
                                    readonly label: string;
                                    readonly domainMultiplicity: string;
                                    readonly entryProfile: {
                                        readonly count: number;
                                        readonly min?: components["schemas"]["ExtendedFloat"];
                                        readonly max?: components["schemas"]["ExtendedFloat"];
                                        readonly mean?: number;
                                        readonly stddev?: number;
                                        readonly buckets: readonly {
                                            readonly left: components["schemas"]["ExtendedFloat"];
                                            readonly right: components["schemas"]["ExtendedFloat"];
                                            readonly count: number;
                                        }[];
                                    };
                                }[];
                                readonly constraints: readonly {
                                    readonly label: string;
                                    readonly domainMultiplicity: string;
                                    readonly coefficientMultiplicity: string;
                                    readonly rowCount: number;
                                    readonly columnCount: number;
                                    readonly weightProfile: {
                                        readonly count: number;
                                        readonly min?: components["schemas"]["ExtendedFloat"];
                                        readonly max?: components["schemas"]["ExtendedFloat"];
                                        readonly mean?: number;
                                        readonly stddev?: number;
                                        readonly buckets: readonly {
                                            readonly left: components["schemas"]["ExtendedFloat"];
                                            readonly right: components["schemas"]["ExtendedFloat"];
                                            readonly count: number;
                                        }[];
                                    };
                                    readonly reifiedInMillis: number;
                                }[];
                                readonly variables: readonly components["schemas"]["ProblemVariableSummary"][];
                                readonly objectives: readonly {
                                    readonly label: string;
                                    readonly coefficientMultiplicity: string;
                                    readonly weightProfile: {
                                        readonly count: number;
                                        readonly min?: components["schemas"]["ExtendedFloat"];
                                        readonly max?: components["schemas"]["ExtendedFloat"];
                                        readonly mean?: number;
                                        readonly stddev?: number;
                                        readonly buckets: readonly {
                                            readonly left: components["schemas"]["ExtendedFloat"];
                                            readonly right: components["schemas"]["ExtendedFloat"];
                                            readonly count: number;
                                        }[];
                                    };
                                    readonly reifiedInMillis: number;
                                }[];
                            };
                            readonly solution?: {
                                readonly variables: readonly {
                                    readonly label: string;
                                    readonly resultProfile: {
                                        readonly count: number;
                                        readonly min?: components["schemas"]["ExtendedFloat"];
                                        readonly max?: components["schemas"]["ExtendedFloat"];
                                        readonly mean?: number;
                                        readonly stddev?: number;
                                        readonly buckets: readonly {
                                            readonly left: components["schemas"]["ExtendedFloat"];
                                            readonly right: components["schemas"]["ExtendedFloat"];
                                            readonly count: number;
                                        }[];
                                    };
                                }[];
                            };
                        };
                        readonly outcome: {
                            readonly status: components["schemas"]["SolveStatus"];
                            readonly objectiveValue?: number;
                            readonly relativeGap?: components["schemas"]["ExtendedFloat"];
                            [key: string]: unknown;
                        };
                        readonly outputs?: {
                            /**
                             * @description All entries where the constraint is active. Unlike for variables,
                             * zero-valued entries are included as they represent tight
                             * constraints.
                             */
                            readonly constraints: readonly {
                                readonly label: string;
                                readonly entries: readonly {
                                    readonly key: readonly components["schemas"]["KeyItem"][];
                                    readonly value: number;
                                    readonly dualValue?: number;
                                }[];
                            }[];
                            /** @description Entries with zero primal value and null dual value are omitted. */
                            readonly variables: readonly {
                                readonly label: string;
                                readonly entries: readonly {
                                    readonly key: readonly components["schemas"]["KeyItem"][];
                                    readonly value: number;
                                    readonly dualValue?: number;
                                }[];
                            }[];
                        };
                    };
                    readonly "application/json-seq": Asyncify<readonly (({
                        /** @enum {string} */
                        readonly kind: "reifying";
                        readonly progress: {
                            /** @enum {string} */
                            readonly kind: "constraint";
                            readonly summary: {
                                readonly label: string;
                                readonly domainMultiplicity: string;
                                readonly coefficientMultiplicity: string;
                                readonly rowCount: number;
                                readonly columnCount: number;
                                readonly weightProfile: {
                                    readonly count: number;
                                    readonly min?: components["schemas"]["ExtendedFloat"];
                                    readonly max?: components["schemas"]["ExtendedFloat"];
                                    readonly mean?: number;
                                    readonly stddev?: number;
                                    readonly buckets: readonly {
                                        readonly left: components["schemas"]["ExtendedFloat"];
                                        readonly right: components["schemas"]["ExtendedFloat"];
                                        readonly count: number;
                                    }[];
                                };
                                readonly reifiedInMillis: number;
                            };
                        } | {
                            /** @enum {string} */
                            readonly kind: "objective";
                            readonly summary: {
                                readonly label: string;
                                readonly coefficientMultiplicity: string;
                                readonly weightProfile: {
                                    readonly count: number;
                                    readonly min?: components["schemas"]["ExtendedFloat"];
                                    readonly max?: components["schemas"]["ExtendedFloat"];
                                    readonly mean?: number;
                                    readonly stddev?: number;
                                    readonly buckets: readonly {
                                        readonly left: components["schemas"]["ExtendedFloat"];
                                        readonly right: components["schemas"]["ExtendedFloat"];
                                        readonly count: number;
                                    }[];
                                };
                                readonly reifiedInMillis: number;
                            };
                        };
                    }) | {
                        /** @enum {string} */
                        readonly kind: "reified";
                        readonly summary: {
                            readonly dimensions: readonly components["schemas"]["ProblemDimensionSummary"][];
                            readonly parameters: readonly {
                                readonly label: string;
                                readonly domainMultiplicity: string;
                                readonly entryProfile: {
                                    readonly count: number;
                                    readonly min?: components["schemas"]["ExtendedFloat"];
                                    readonly max?: components["schemas"]["ExtendedFloat"];
                                    readonly mean?: number;
                                    readonly stddev?: number;
                                    readonly buckets: readonly {
                                        readonly left: components["schemas"]["ExtendedFloat"];
                                        readonly right: components["schemas"]["ExtendedFloat"];
                                        readonly count: number;
                                    }[];
                                };
                            }[];
                            readonly constraints: readonly {
                                readonly label: string;
                                readonly domainMultiplicity: string;
                                readonly coefficientMultiplicity: string;
                                readonly rowCount: number;
                                readonly columnCount: number;
                                readonly weightProfile: {
                                    readonly count: number;
                                    readonly min?: components["schemas"]["ExtendedFloat"];
                                    readonly max?: components["schemas"]["ExtendedFloat"];
                                    readonly mean?: number;
                                    readonly stddev?: number;
                                    readonly buckets: readonly {
                                        readonly left: components["schemas"]["ExtendedFloat"];
                                        readonly right: components["schemas"]["ExtendedFloat"];
                                        readonly count: number;
                                    }[];
                                };
                                readonly reifiedInMillis: number;
                            }[];
                            readonly variables: readonly components["schemas"]["ProblemVariableSummary"][];
                            readonly objectives: readonly {
                                readonly label: string;
                                readonly coefficientMultiplicity: string;
                                readonly weightProfile: {
                                    readonly count: number;
                                    readonly min?: components["schemas"]["ExtendedFloat"];
                                    readonly max?: components["schemas"]["ExtendedFloat"];
                                    readonly mean?: number;
                                    readonly stddev?: number;
                                    readonly buckets: readonly {
                                        readonly left: components["schemas"]["ExtendedFloat"];
                                        readonly right: components["schemas"]["ExtendedFloat"];
                                        readonly count: number;
                                    }[];
                                };
                                readonly reifiedInMillis: number;
                            }[];
                        };
                    } | ({
                        /** @enum {string} */
                        readonly kind: "solving";
                        readonly progress: {
                            /** @enum {string} */
                            readonly kind: "activity";
                            readonly relativeGap?: components["schemas"]["ExtendedFloat"];
                            readonly cutCount?: number;
                            readonly lpIterationCount?: number;
                        } | {
                            /** @enum {string} */
                            readonly kind: "epsilonConstraint";
                            readonly objectiveValue: number;
                        };
                    }) | {
                        /** @enum {string} */
                        readonly kind: "denormalized";
                        readonly summary: {
                            readonly variables: readonly {
                                readonly label: string;
                                readonly resultProfile: {
                                    readonly count: number;
                                    readonly min?: components["schemas"]["ExtendedFloat"];
                                    readonly max?: components["schemas"]["ExtendedFloat"];
                                    readonly mean?: number;
                                    readonly stddev?: number;
                                    readonly buckets: readonly {
                                        readonly left: components["schemas"]["ExtendedFloat"];
                                        readonly right: components["schemas"]["ExtendedFloat"];
                                        readonly count: number;
                                    }[];
                                };
                            }[];
                        };
                    } | {
                        /** @enum {string} */
                        readonly kind: "solved";
                        readonly outcome: {
                            readonly status: components["schemas"]["SolveStatus"];
                            readonly objectiveValue?: number;
                            readonly relativeGap?: components["schemas"]["ExtendedFloat"];
                            [key: string]: unknown;
                        };
                        readonly outputs?: {
                            /**
                             * @description All entries where the constraint is active. Unlike for variables,
                             * zero-valued entries are included as they represent tight
                             * constraints.
                             */
                            readonly constraints: readonly {
                                readonly label: string;
                                readonly entries: readonly {
                                    readonly key: readonly components["schemas"]["KeyItem"][];
                                    readonly value: number;
                                    readonly dualValue?: number;
                                }[];
                            }[];
                            /** @description Entries with zero primal value and null dual value are omitted. */
                            readonly variables: readonly {
                                readonly label: string;
                                readonly entries: readonly {
                                    readonly key: readonly components["schemas"]["KeyItem"][];
                                    readonly value: number;
                                    readonly dualValue?: number;
                                }[];
                            }[];
                        };
                    } | {
                        /** @enum {string} */
                        readonly kind: "error";
                        readonly status: string;
                        readonly error: {
                            readonly message: string;
                            readonly code?: string;
                            readonly tags?: {
                                [key: string]: unknown;
                            };
                        };
                    })[]>;
                };
            };
            default: components["responses"]["Error2"];
        };
    };
    /** @description View a formatted representation of an optimization problem's underlying solver instructions */
    formatProblem: {
        readonly requestBody: {
            readonly content: {
                readonly "application/json": {
                    readonly problem: {
                        readonly formulation: components["schemas"]["InlineProblemFormulation"] | components["schemas"]["RemoteProblemFormulation"];
                        readonly inputs: {
                            readonly parameters: readonly {
                                readonly label: string;
                                /**
                                 * @description Value used for entries which are not explicitly specified in the
                                 * array below. Defaults to 0 when unset.
                                 */
                                readonly defaultValue?: components["schemas"]["ExtendedFloat"];
                                readonly entries: readonly {
                                    readonly key: readonly components["schemas"]["KeyItem"][];
                                    /** @description Defaults to 1 when unset */
                                    readonly value?: components["schemas"]["ExtendedFloat"];
                                }[];
                            }[];
                            readonly dimensions?: readonly {
                                readonly label: string;
                                readonly items: readonly components["schemas"]["KeyItem"][];
                            }[];
                        };
                        readonly options?: components["schemas"]["SolveOptions"];
                        readonly strategy?: {
                            readonly isMaximization: boolean;
                            readonly target: components["schemas"]["WeightedSumTarget"];
                            readonly epsilonConstraints?: readonly {
                                readonly target: components["schemas"]["WeightedSumTarget"];
                                readonly absoluteTolerance?: number;
                                readonly relativeTolerance?: number;
                                [key: string]: unknown;
                            }[];
                            [key: string]: unknown;
                        };
                        readonly transformations?: readonly (({
                            /** @enum {string} */
                            readonly kind: "relaxConstraint";
                            readonly label: string;
                            /**
                             * @description Strategy for computing the cost of relaxing a constraint.
                             *
                             * + `TOTAL_DEVIATION`: Cost proportional to the total sum of the
                             *   (absolute value of) deviation.
                             * + `MAX_DEVIATION`: Cost proportional to the maximum deviation.
                             * + `DEVIATION_CARDINALITY`: Cost proportional to the number of rows with
                             *   non-zero deviation. This penalty requires the relaxation to be
                             *   bounded with finite values.
                             *
                             * The default is `TOTAL_DEVIATION`.
                             *
                             * @enum {string}
                             */
                            readonly penalty?: "TOTAL_DEVIATION" | "MAX_DEVIATION" | "DEVIATION_CARDINALITY";
                            /**
                             * @description When set to `true`, adds deviation bound parameters
                             * (`$label_deficitCap` and/or `$label_surplusCap`).
                             */
                            readonly isCapped?: boolean;
                        }) | {
                            /** @enum {string} */
                            readonly kind: "omitConstraint";
                            readonly label: string;
                        } | {
                            /** @enum {string} */
                            readonly kind: "omitObjective";
                            readonly label: string;
                        } | {
                            /** @enum {string} */
                            readonly kind: "pinVariable";
                            readonly label: string;
                        } | {
                            /** @enum {string} */
                            readonly kind: "densifyVariable";
                            readonly label: string;
                        } | {
                            /** @enum {string} */
                            readonly kind: "constrainObjective";
                            readonly label: string;
                            readonly maxValue?: number;
                            readonly minValue?: number;
                        })[];
                    };
                    /**
                     * @description The values of prior targets, meaningful when using a
                     * strategy with epsilon-constraints. The next target will
                     * have its instructions returned. Defaults to an empty array
                     * (i.e. the first target will be returned).
                     */
                    readonly priorTargetValues?: readonly number[];
                    [key: string]: unknown;
                };
            };
        };
        responses: {
            /** @description Formatted solver inputs */
            200: {
                content: {
                    readonly "text/plain": string;
                };
            };
            default: components["responses"]["Error2"];
        };
    };
    /** @description View summary statistics about a solve */
    summarizeProblem: {
        readonly requestBody: {
            readonly content: {
                readonly "application/json": {
                    readonly problem: {
                        readonly formulation: components["schemas"]["InlineProblemFormulation"] | components["schemas"]["RemoteProblemFormulation"];
                        readonly inputs: {
                            readonly parameters: readonly {
                                readonly label: string;
                                /**
                                 * @description Value used for entries which are not explicitly specified in the
                                 * array below. Defaults to 0 when unset.
                                 */
                                readonly defaultValue?: components["schemas"]["ExtendedFloat"];
                                readonly entries: readonly {
                                    readonly key: readonly components["schemas"]["KeyItem"][];
                                    /** @description Defaults to 1 when unset */
                                    readonly value?: components["schemas"]["ExtendedFloat"];
                                }[];
                            }[];
                            readonly dimensions?: readonly {
                                readonly label: string;
                                readonly items: readonly components["schemas"]["KeyItem"][];
                            }[];
                        };
                        readonly options?: components["schemas"]["SolveOptions"];
                        readonly strategy?: {
                            readonly isMaximization: boolean;
                            readonly target: components["schemas"]["WeightedSumTarget"];
                            readonly epsilonConstraints?: readonly {
                                readonly target: components["schemas"]["WeightedSumTarget"];
                                readonly absoluteTolerance?: number;
                                readonly relativeTolerance?: number;
                                [key: string]: unknown;
                            }[];
                            [key: string]: unknown;
                        };
                        readonly transformations?: readonly (({
                            /** @enum {string} */
                            readonly kind: "relaxConstraint";
                            readonly label: string;
                            /**
                             * @description Strategy for computing the cost of relaxing a constraint.
                             *
                             * + `TOTAL_DEVIATION`: Cost proportional to the total sum of the
                             *   (absolute value of) deviation.
                             * + `MAX_DEVIATION`: Cost proportional to the maximum deviation.
                             * + `DEVIATION_CARDINALITY`: Cost proportional to the number of rows with
                             *   non-zero deviation. This penalty requires the relaxation to be
                             *   bounded with finite values.
                             *
                             * The default is `TOTAL_DEVIATION`.
                             *
                             * @enum {string}
                             */
                            readonly penalty?: "TOTAL_DEVIATION" | "MAX_DEVIATION" | "DEVIATION_CARDINALITY";
                            /**
                             * @description When set to `true`, adds deviation bound parameters
                             * (`$label_deficitCap` and/or `$label_surplusCap`).
                             */
                            readonly isCapped?: boolean;
                        }) | {
                            /** @enum {string} */
                            readonly kind: "omitConstraint";
                            readonly label: string;
                        } | {
                            /** @enum {string} */
                            readonly kind: "omitObjective";
                            readonly label: string;
                        } | {
                            /** @enum {string} */
                            readonly kind: "pinVariable";
                            readonly label: string;
                        } | {
                            /** @enum {string} */
                            readonly kind: "densifyVariable";
                            readonly label: string;
                        } | {
                            /** @enum {string} */
                            readonly kind: "constrainObjective";
                            readonly label: string;
                            readonly maxValue?: number;
                            readonly minValue?: number;
                        })[];
                    };
                    [key: string]: unknown;
                };
            };
        };
        responses: {
            /** @description Input summary statistics */
            200: {
                content: {
                    readonly "application/json": {
                        readonly dimensions: readonly components["schemas"]["ProblemDimensionSummary"][];
                        readonly parameters: readonly {
                            readonly label: string;
                            readonly domainMultiplicity: string;
                            readonly entryProfile: {
                                readonly count: number;
                                readonly min?: components["schemas"]["ExtendedFloat"];
                                readonly max?: components["schemas"]["ExtendedFloat"];
                                readonly mean?: number;
                                readonly stddev?: number;
                                readonly buckets: readonly {
                                    readonly left: components["schemas"]["ExtendedFloat"];
                                    readonly right: components["schemas"]["ExtendedFloat"];
                                    readonly count: number;
                                }[];
                            };
                        }[];
                        readonly constraints: readonly {
                            readonly label: string;
                            readonly domainMultiplicity: string;
                            readonly coefficientMultiplicity: string;
                            readonly rowCount: number;
                            readonly columnCount: number;
                            readonly weightProfile: {
                                readonly count: number;
                                readonly min?: components["schemas"]["ExtendedFloat"];
                                readonly max?: components["schemas"]["ExtendedFloat"];
                                readonly mean?: number;
                                readonly stddev?: number;
                                readonly buckets: readonly {
                                    readonly left: components["schemas"]["ExtendedFloat"];
                                    readonly right: components["schemas"]["ExtendedFloat"];
                                    readonly count: number;
                                }[];
                            };
                            readonly reifiedInMillis: number;
                        }[];
                        readonly variables: readonly components["schemas"]["ProblemVariableSummary"][];
                        readonly objectives: readonly {
                            readonly label: string;
                            readonly coefficientMultiplicity: string;
                            readonly weightProfile: {
                                readonly count: number;
                                readonly min?: components["schemas"]["ExtendedFloat"];
                                readonly max?: components["schemas"]["ExtendedFloat"];
                                readonly mean?: number;
                                readonly stddev?: number;
                                readonly buckets: readonly {
                                    readonly left: components["schemas"]["ExtendedFloat"];
                                    readonly right: components["schemas"]["ExtendedFloat"];
                                    readonly count: number;
                                }[];
                            };
                            readonly reifiedInMillis: number;
                        }[];
                    };
                };
            };
            default: components["responses"]["Error2"];
        };
    };
    /** @description Solve an optimization problem asynchronously */
    queueSolve: {
        readonly requestBody: components["requestBodies"]["QueueSolveRequest"];
        responses: {
            /** @description Started attempt metadata */
            200: {
                content: {
                    readonly "application/json": {
                        readonly uuid: string;
                        readonly expiresAt: string;
                        [key: string]: unknown;
                    };
                };
            };
            default: components["responses"]["Error2"];
        };
    };
    /** @description Retrieve a queued solve's input data */
    getQueuedSolveInputs: {
        parameters: {
            path: {
                uuid: components["parameters"]["QueuedSolveUuid"];
            };
        };
        responses: {
            /** @description Inputs found */
            200: {
                content: {
                    readonly "application/json": components["schemas"]["SolveInputs"];
                };
            };
            /** @description No matching attempt found */
            404: {
                content: never;
            };
            default: components["responses"]["Error2"];
        };
    };
    /** @description Retrieve a queued solve's output data */
    getQueuedSolveOutputs: {
        parameters: {
            path: {
                uuid: components["parameters"]["QueuedSolveUuid"];
            };
        };
        responses: {
            /** @description Outputs found */
            200: {
                content: {
                    readonly "application/json": components["schemas"]["SolveOutputs"];
                };
            };
            /** @description No matching attempt found */
            404: {
                content: never;
            };
            /** @description The queued solve exists but does not have any outputs. This could be because it is still pending or was infeasible. */
            409: {
                content: never;
            };
            default: components["responses"]["Error2"];
        };
    };
}
export type { operations as Operations };
export type Schemas = components['schemas'];
export type Schema<K extends keyof Schemas> = Schemas[K];
type RequestBodyFor<O extends OperationType, M extends BodyMimeTypes<O> = BodyMimeTypes<O>> = Lookup<Lookup<Lookup<O, 'requestBody'>, 'content'>, M, never>;
type RequestParametersFor<O extends OperationType> = Lookup<O['parameters'], 'path', {}> & Lookup<O['parameters'], 'query', {}> & Lookup<O['parameters'], 'headers', {}>;
type ResponseBodyFor<O extends OperationType, C extends keyof O['responses'], M extends ResponseMimeTypes<O['responses'], C> = ResponseMimeTypes<O['responses'], C>> = Get<Lookup<O['responses'][C], 'content'>, M>;
export type RequestBody<K extends keyof operations, M extends BodyMimeTypes<operations[K]> = BodyMimeTypes<operations[K]>> = RequestBodyFor<operations[K], M>;
export type RequestParameters<K extends keyof operations> = RequestParametersFor<operations[K]>;
export type ResponseBody<K extends keyof operations, C extends keyof operations[K]['responses'] = keyof operations[K]['responses'], M extends ResponseMimeTypes<operations[K]['responses'], C> = ResponseMimeTypes<operations[K]['responses'], C>> = ResponseBodyFor<operations[K], C, M>;
export type Sdk<F extends BaseFetch = BaseFetch> = SdkFor<operations, F>;
export declare const serverAddresses: readonly ["https://api.cloud.opvious.io/"];
type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
export declare function createSdk<F extends BaseFetch>(arg?: Address | Optional<SdkConfig<F>, 'address'>): Sdk<F>;