Class OpviousClient

Opvious API client.

Constructors

constructor

Properties

apiEndpoint authenticated graphqlSdk sdk telemetry

Methods

cancelSolve deleteFormulation fetchFormulationOutline fetchMember fetchSolve fetchSolveInputs fetchSolveOutputs formatProblem generateAccessToken listAuthorizations paginateAttempts paginateCreditCharges paginateCreditGrants paginateFormulationTags paginateFormulations paginateSolveNotifications parseSources queueSolve registerSpecification revokeAuthorization runSolve trackSolve updateFormulation waitForOutcome create

Constructors

Private constructor

  • new OpviousClient(telemetry, authenticated, apiEndpoint, sdk, graphqlSdk): OpviousClient

  • Parameters

    • telemetry: Telemetry
    • authenticated: boolean

      Whether the client was created with an API token.

    • apiEndpoint: string

      Base API endpoint.

    • sdk: SdkFor<operations, ((url, init?) => Promise<Response>)>
    • graphqlSdk: {
          CancelQueuedSolve(variables, options?): Promise<ExecutionResult<CancelQueuedSolveMutation, {
              trace?: string;
          }>>;
          DeleteFormulation(variables, options?): Promise<ExecutionResult<DeleteFormulationMutation, {
              trace?: string;
          }>>;
          FetchFormulation(variables, options?): Promise<ExecutionResult<FetchFormulationQuery, {
              trace?: string;
          }>>;
          FetchMember(variables?, options?): Promise<ExecutionResult<FetchMemberQuery, {
              trace?: string;
          }>>;
          FetchOutline(variables, options?): Promise<ExecutionResult<FetchOutlineQuery, {
              trace?: string;
          }>>;
          FetchQueuedSolve(variables, options?): Promise<ExecutionResult<FetchQueuedSolveQuery, {
              trace?: string;
          }>>;
          FetchQueuedSolveSummaries(variables, options?): Promise<ExecutionResult<FetchQueuedSolveSummariesQuery, {
              trace?: string;
          }>>;
          FetchSpecification(variables, options?): Promise<ExecutionResult<FetchSpecificationQuery, {
              trace?: string;
          }>>;
          FetchSpecificationTag(variables, options?): Promise<ExecutionResult<FetchSpecificationTagQuery, {
              trace?: string;
          }>>;
          GenerateAuthorization(variables, options?): Promise<ExecutionResult<GenerateAuthorizationMutation, {
              trace?: string;
          }>>;
          ListAuthorizations(variables?, options?): Promise<ExecutionResult<ListAuthorizationsQuery, {
              trace?: string;
          }>>;
          PaginateAttempts(variables?, options?): Promise<ExecutionResult<PaginateAttemptsQuery, {
              trace?: string;
          }>>;
          PaginateCreditCharges(variables?, options?): Promise<ExecutionResult<PaginateCreditChargesQuery, {
              trace?: string;
          }>>;
          PaginateCreditGrants(variables?, options?): Promise<ExecutionResult<PaginateCreditGrantsQuery, {
              trace?: string;
          }>>;
          PaginateFormulationAttempts(variables, options?): Promise<ExecutionResult<PaginateFormulationAttemptsQuery, {
              trace?: string;
          }>>;
          PaginateFormulationSpecifications(variables, options?): Promise<ExecutionResult<PaginateFormulationSpecificationsQuery, {
              trace?: string;
          }>>;
          PaginateFormulationTags(variables, options?): Promise<ExecutionResult<PaginateFormulationTagsQuery, {
              trace?: string;
          }>>;
          PaginateFormulations(variables?, options?): Promise<ExecutionResult<PaginateFormulationsQuery, {
              trace?: string;
          }>>;
          PaginateQueuedSolveAttempts(variables?, options?): Promise<ExecutionResult<PaginateQueuedSolveAttemptsQuery, {
              trace?: string;
          }>>;
          PaginateQueuedSolveNotifications(variables, options?): Promise<ExecutionResult<PaginateQueuedSolveNotificationsQuery, {
              trace?: string;
          }>>;
          PollQueuedSolve(variables, options?): Promise<ExecutionResult<PollQueuedSolveQuery, {
              trace?: string;
          }>>;
          RegisterSpecification(variables, options?): Promise<ExecutionResult<RegisterSpecificationMutation, {
              trace?: string;
          }>>;
          RevokeAuthorization(variables, options?): Promise<ExecutionResult<RevokeAuthorizationMutation, {
              trace?: string;
          }>>;
          UpdateFormulation(variables, options?): Promise<ExecutionResult<UpdateFormulationMutation, {
              trace?: string;
          }>>;
      }
      • CancelQueuedSolve:function
        • CancelQueuedSolve(variables, options?): Promise<ExecutionResult<CancelQueuedSolveMutation, {
              trace?: string;
          }>>

        • Parameters

          • variables: Exact<{
                uuid: string;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<CancelQueuedSolveMutation, {
              trace?: string;
          }>>

      • DeleteFormulation:function
        • DeleteFormulation(variables, options?): Promise<ExecutionResult<DeleteFormulationMutation, {
              trace?: string;
          }>>

        • Parameters

          • variables: Exact<{
                name: string;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<DeleteFormulationMutation, {
              trace?: string;
          }>>

      • FetchFormulation:function
        • FetchFormulation(variables, options?): Promise<ExecutionResult<FetchFormulationQuery, {
              trace?: string;
          }>>

        • Parameters

          • variables: Exact<{
                name: string;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<FetchFormulationQuery, {
              trace?: string;
          }>>

      • FetchMember:function
        • FetchMember(variables?, options?): Promise<ExecutionResult<FetchMemberQuery, {
              trace?: string;
          }>>

        • Parameters

          • Optional variables: Exact<{
                [key: string]: never;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<FetchMemberQuery, {
              trace?: string;
          }>>

      • FetchOutline:function
        • FetchOutline(variables, options?): Promise<ExecutionResult<FetchOutlineQuery, {
              trace?: string;
          }>>

        • Parameters

          • variables: Exact<{
                formulationName: string;
                tagName?: InputMaybe<string>;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<FetchOutlineQuery, {
              trace?: string;
          }>>

      • FetchQueuedSolve:function
        • FetchQueuedSolve(variables, options?): Promise<ExecutionResult<FetchQueuedSolveQuery, {
              trace?: string;
          }>>

        • Parameters

          • variables: Exact<{
                uuid: string;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<FetchQueuedSolveQuery, {
              trace?: string;
          }>>

      • FetchQueuedSolveSummaries:function
        • FetchQueuedSolveSummaries(variables, options?): Promise<ExecutionResult<FetchQueuedSolveSummariesQuery, {
              trace?: string;
          }>>

        • Parameters

          • variables: Exact<{
                uuid: string;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<FetchQueuedSolveSummariesQuery, {
              trace?: string;
          }>>

      • FetchSpecification:function
        • FetchSpecification(variables, options?): Promise<ExecutionResult<FetchSpecificationQuery, {
              trace?: string;
          }>>

        • Parameters

          • variables: Exact<{
                formulationName: string;
                revno: number;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<FetchSpecificationQuery, {
              trace?: string;
          }>>

      • FetchSpecificationTag:function
        • FetchSpecificationTag(variables, options?): Promise<ExecutionResult<FetchSpecificationTagQuery, {
              trace?: string;
          }>>

        • Parameters

          • variables: Exact<{
                formulationName: string;
                name?: InputMaybe<string>;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<FetchSpecificationTagQuery, {
              trace?: string;
          }>>

      • GenerateAuthorization:function
        • GenerateAuthorization(variables, options?): Promise<ExecutionResult<GenerateAuthorizationMutation, {
              trace?: string;
          }>>

        • Parameters

          • variables: Exact<{
                input: GenerateAuthorizationInput;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<GenerateAuthorizationMutation, {
              trace?: string;
          }>>

      • ListAuthorizations:function
        • ListAuthorizations(variables?, options?): Promise<ExecutionResult<ListAuthorizationsQuery, {
              trace?: string;
          }>>

        • Parameters

          • Optional variables: Exact<{
                [key: string]: never;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<ListAuthorizationsQuery, {
              trace?: string;
          }>>

      • PaginateAttempts:function
        • PaginateAttempts(variables?, options?): Promise<ExecutionResult<PaginateAttemptsQuery, {
              trace?: string;
          }>>

        • Parameters

          • Optional variables: Exact<{
                after?: InputMaybe<string>;
                before?: InputMaybe<string>;
                filter?: InputMaybe<AttemptFilter>;
                first?: InputMaybe<number>;
                last?: InputMaybe<number>;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<PaginateAttemptsQuery, {
              trace?: string;
          }>>

      • PaginateCreditCharges:function
        • PaginateCreditCharges(variables?, options?): Promise<ExecutionResult<PaginateCreditChargesQuery, {
              trace?: string;
          }>>

        • Parameters

          • Optional variables: Exact<{
                after?: InputMaybe<string>;
                before?: InputMaybe<string>;
                first?: InputMaybe<number>;
                last?: InputMaybe<number>;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<PaginateCreditChargesQuery, {
              trace?: string;
          }>>

      • PaginateCreditGrants:function
        • PaginateCreditGrants(variables?, options?): Promise<ExecutionResult<PaginateCreditGrantsQuery, {
              trace?: string;
          }>>

        • Parameters

          • Optional variables: Exact<{
                after?: InputMaybe<string>;
                before?: InputMaybe<string>;
                first?: InputMaybe<number>;
                last?: InputMaybe<number>;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<PaginateCreditGrantsQuery, {
              trace?: string;
          }>>

      • PaginateFormulationAttempts:function
        • PaginateFormulationAttempts(variables, options?): Promise<ExecutionResult<PaginateFormulationAttemptsQuery, {
              trace?: string;
          }>>

        • Parameters

          • variables: Exact<{
                before?: InputMaybe<string>;
                filter?: InputMaybe<AttemptFilter>;
                last: number;
                name: string;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<PaginateFormulationAttemptsQuery, {
              trace?: string;
          }>>

      • PaginateFormulationSpecifications:function
        • PaginateFormulationSpecifications(variables, options?): Promise<ExecutionResult<PaginateFormulationSpecificationsQuery, {
              trace?: string;
          }>>

        • Parameters

          • variables: Exact<{
                after?: InputMaybe<string>;
                before?: InputMaybe<string>;
                first?: InputMaybe<number>;
                formulationName: string;
                last?: InputMaybe<number>;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<PaginateFormulationSpecificationsQuery, {
              trace?: string;
          }>>

      • PaginateFormulationTags:function
        • PaginateFormulationTags(variables, options?): Promise<ExecutionResult<PaginateFormulationTagsQuery, {
              trace?: string;
          }>>

        • Parameters

          • variables: Exact<{
                after?: InputMaybe<string>;
                filter?: InputMaybe<FormulationTagsFilter>;
                first: number;
                formulationName: string;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<PaginateFormulationTagsQuery, {
              trace?: string;
          }>>

      • PaginateFormulations:function
        • PaginateFormulations(variables?, options?): Promise<ExecutionResult<PaginateFormulationsQuery, {
              trace?: string;
          }>>

        • Parameters

          • Optional variables: Exact<{
                after?: InputMaybe<string>;
                before?: InputMaybe<string>;
                filter?: InputMaybe<FormulationFilter>;
                first?: InputMaybe<number>;
                last?: InputMaybe<number>;
                orderBy?: InputMaybe<FormulationOrderBy>;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<PaginateFormulationsQuery, {
              trace?: string;
          }>>

      • PaginateQueuedSolveAttempts:function
        • PaginateQueuedSolveAttempts(variables?, options?): Promise<ExecutionResult<PaginateQueuedSolveAttemptsQuery, {
              trace?: string;
          }>>

        • Parameters

          • Optional variables: Exact<{
                after?: InputMaybe<string>;
                before?: InputMaybe<string>;
                filter?: InputMaybe<AttemptFilter>;
                first?: InputMaybe<number>;
                last?: InputMaybe<number>;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<PaginateQueuedSolveAttemptsQuery, {
              trace?: string;
          }>>

      • PaginateQueuedSolveNotifications:function
        • PaginateQueuedSolveNotifications(variables, options?): Promise<ExecutionResult<PaginateQueuedSolveNotificationsQuery, {
              trace?: string;
          }>>

        • Parameters

          • variables: Exact<{
                before?: InputMaybe<string>;
                last: number;
                uuid: string;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<PaginateQueuedSolveNotificationsQuery, {
              trace?: string;
          }>>

      • PollQueuedSolve:function
        • PollQueuedSolve(variables, options?): Promise<ExecutionResult<PollQueuedSolveQuery, {
              trace?: string;
          }>>

        • Parameters

          • variables: Exact<{
                uuid: string;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<PollQueuedSolveQuery, {
              trace?: string;
          }>>

      • RegisterSpecification:function
        • RegisterSpecification(variables, options?): Promise<ExecutionResult<RegisterSpecificationMutation, {
              trace?: string;
          }>>

        • Parameters

          • variables: Exact<{
                input: RegisterSpecificationInput;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<RegisterSpecificationMutation, {
              trace?: string;
          }>>

      • RevokeAuthorization:function
        • RevokeAuthorization(variables, options?): Promise<ExecutionResult<RevokeAuthorizationMutation, {
              trace?: string;
          }>>

        • Parameters

          • variables: Exact<{
                name: string;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<RevokeAuthorizationMutation, {
              trace?: string;
          }>>

      • UpdateFormulation:function
        • UpdateFormulation(variables, options?): Promise<ExecutionResult<UpdateFormulationMutation, {
              trace?: string;
          }>>

        • Parameters

          • variables: Exact<{
                input: UpdateFormulationInput;
            }>
          • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

          Returns Promise<ExecutionResult<UpdateFormulationMutation, {
              trace?: string;
          }>>

    Returns OpviousClient

Properties

Readonly apiEndpoint

apiEndpoint: string

Base API endpoint.

Readonly authenticated

authenticated: boolean

Whether the client was created with an API token.

Private Readonly graphqlSdk

graphqlSdk: {
    CancelQueuedSolve(variables, options?): Promise<ExecutionResult<CancelQueuedSolveMutation, {
        trace?: string;
    }>>;
    DeleteFormulation(variables, options?): Promise<ExecutionResult<DeleteFormulationMutation, {
        trace?: string;
    }>>;
    FetchFormulation(variables, options?): Promise<ExecutionResult<FetchFormulationQuery, {
        trace?: string;
    }>>;
    FetchMember(variables?, options?): Promise<ExecutionResult<FetchMemberQuery, {
        trace?: string;
    }>>;
    FetchOutline(variables, options?): Promise<ExecutionResult<FetchOutlineQuery, {
        trace?: string;
    }>>;
    FetchQueuedSolve(variables, options?): Promise<ExecutionResult<FetchQueuedSolveQuery, {
        trace?: string;
    }>>;
    FetchQueuedSolveSummaries(variables, options?): Promise<ExecutionResult<FetchQueuedSolveSummariesQuery, {
        trace?: string;
    }>>;
    FetchSpecification(variables, options?): Promise<ExecutionResult<FetchSpecificationQuery, {
        trace?: string;
    }>>;
    FetchSpecificationTag(variables, options?): Promise<ExecutionResult<FetchSpecificationTagQuery, {
        trace?: string;
    }>>;
    GenerateAuthorization(variables, options?): Promise<ExecutionResult<GenerateAuthorizationMutation, {
        trace?: string;
    }>>;
    ListAuthorizations(variables?, options?): Promise<ExecutionResult<ListAuthorizationsQuery, {
        trace?: string;
    }>>;
    PaginateAttempts(variables?, options?): Promise<ExecutionResult<PaginateAttemptsQuery, {
        trace?: string;
    }>>;
    PaginateCreditCharges(variables?, options?): Promise<ExecutionResult<PaginateCreditChargesQuery, {
        trace?: string;
    }>>;
    PaginateCreditGrants(variables?, options?): Promise<ExecutionResult<PaginateCreditGrantsQuery, {
        trace?: string;
    }>>;
    PaginateFormulationAttempts(variables, options?): Promise<ExecutionResult<PaginateFormulationAttemptsQuery, {
        trace?: string;
    }>>;
    PaginateFormulationSpecifications(variables, options?): Promise<ExecutionResult<PaginateFormulationSpecificationsQuery, {
        trace?: string;
    }>>;
    PaginateFormulationTags(variables, options?): Promise<ExecutionResult<PaginateFormulationTagsQuery, {
        trace?: string;
    }>>;
    PaginateFormulations(variables?, options?): Promise<ExecutionResult<PaginateFormulationsQuery, {
        trace?: string;
    }>>;
    PaginateQueuedSolveAttempts(variables?, options?): Promise<ExecutionResult<PaginateQueuedSolveAttemptsQuery, {
        trace?: string;
    }>>;
    PaginateQueuedSolveNotifications(variables, options?): Promise<ExecutionResult<PaginateQueuedSolveNotificationsQuery, {
        trace?: string;
    }>>;
    PollQueuedSolve(variables, options?): Promise<ExecutionResult<PollQueuedSolveQuery, {
        trace?: string;
    }>>;
    RegisterSpecification(variables, options?): Promise<ExecutionResult<RegisterSpecificationMutation, {
        trace?: string;
    }>>;
    RevokeAuthorization(variables, options?): Promise<ExecutionResult<RevokeAuthorizationMutation, {
        trace?: string;
    }>>;
    UpdateFormulation(variables, options?): Promise<ExecutionResult<UpdateFormulationMutation, {
        trace?: string;
    }>>;
}

Type declaration

  • CancelQueuedSolve:function
    • CancelQueuedSolve(variables, options?): Promise<ExecutionResult<CancelQueuedSolveMutation, {
          trace?: string;
      }>>

    • Parameters

      • variables: Exact<{
            uuid: string;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<CancelQueuedSolveMutation, {
          trace?: string;
      }>>

  • DeleteFormulation:function
    • DeleteFormulation(variables, options?): Promise<ExecutionResult<DeleteFormulationMutation, {
          trace?: string;
      }>>

    • Parameters

      • variables: Exact<{
            name: string;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<DeleteFormulationMutation, {
          trace?: string;
      }>>

  • FetchFormulation:function
    • FetchFormulation(variables, options?): Promise<ExecutionResult<FetchFormulationQuery, {
          trace?: string;
      }>>

    • Parameters

      • variables: Exact<{
            name: string;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<FetchFormulationQuery, {
          trace?: string;
      }>>

  • FetchMember:function
    • FetchMember(variables?, options?): Promise<ExecutionResult<FetchMemberQuery, {
          trace?: string;
      }>>

    • Parameters

      • Optional variables: Exact<{
            [key: string]: never;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<FetchMemberQuery, {
          trace?: string;
      }>>

  • FetchOutline:function
    • FetchOutline(variables, options?): Promise<ExecutionResult<FetchOutlineQuery, {
          trace?: string;
      }>>

    • Parameters

      • variables: Exact<{
            formulationName: string;
            tagName?: InputMaybe<string>;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<FetchOutlineQuery, {
          trace?: string;
      }>>

  • FetchQueuedSolve:function
    • FetchQueuedSolve(variables, options?): Promise<ExecutionResult<FetchQueuedSolveQuery, {
          trace?: string;
      }>>

    • Parameters

      • variables: Exact<{
            uuid: string;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<FetchQueuedSolveQuery, {
          trace?: string;
      }>>

  • FetchQueuedSolveSummaries:function
    • FetchQueuedSolveSummaries(variables, options?): Promise<ExecutionResult<FetchQueuedSolveSummariesQuery, {
          trace?: string;
      }>>

    • Parameters

      • variables: Exact<{
            uuid: string;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<FetchQueuedSolveSummariesQuery, {
          trace?: string;
      }>>

  • FetchSpecification:function
    • FetchSpecification(variables, options?): Promise<ExecutionResult<FetchSpecificationQuery, {
          trace?: string;
      }>>

    • Parameters

      • variables: Exact<{
            formulationName: string;
            revno: number;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<FetchSpecificationQuery, {
          trace?: string;
      }>>

  • FetchSpecificationTag:function
    • FetchSpecificationTag(variables, options?): Promise<ExecutionResult<FetchSpecificationTagQuery, {
          trace?: string;
      }>>

    • Parameters

      • variables: Exact<{
            formulationName: string;
            name?: InputMaybe<string>;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<FetchSpecificationTagQuery, {
          trace?: string;
      }>>

  • GenerateAuthorization:function
    • GenerateAuthorization(variables, options?): Promise<ExecutionResult<GenerateAuthorizationMutation, {
          trace?: string;
      }>>

    • Parameters

      • variables: Exact<{
            input: GenerateAuthorizationInput;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<GenerateAuthorizationMutation, {
          trace?: string;
      }>>

  • ListAuthorizations:function
    • ListAuthorizations(variables?, options?): Promise<ExecutionResult<ListAuthorizationsQuery, {
          trace?: string;
      }>>

    • Parameters

      • Optional variables: Exact<{
            [key: string]: never;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<ListAuthorizationsQuery, {
          trace?: string;
      }>>

  • PaginateAttempts:function
    • PaginateAttempts(variables?, options?): Promise<ExecutionResult<PaginateAttemptsQuery, {
          trace?: string;
      }>>

    • Parameters

      • Optional variables: Exact<{
            after?: InputMaybe<string>;
            before?: InputMaybe<string>;
            filter?: InputMaybe<AttemptFilter>;
            first?: InputMaybe<number>;
            last?: InputMaybe<number>;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<PaginateAttemptsQuery, {
          trace?: string;
      }>>

  • PaginateCreditCharges:function
    • PaginateCreditCharges(variables?, options?): Promise<ExecutionResult<PaginateCreditChargesQuery, {
          trace?: string;
      }>>

    • Parameters

      • Optional variables: Exact<{
            after?: InputMaybe<string>;
            before?: InputMaybe<string>;
            first?: InputMaybe<number>;
            last?: InputMaybe<number>;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<PaginateCreditChargesQuery, {
          trace?: string;
      }>>

  • PaginateCreditGrants:function
    • PaginateCreditGrants(variables?, options?): Promise<ExecutionResult<PaginateCreditGrantsQuery, {
          trace?: string;
      }>>

    • Parameters

      • Optional variables: Exact<{
            after?: InputMaybe<string>;
            before?: InputMaybe<string>;
            first?: InputMaybe<number>;
            last?: InputMaybe<number>;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<PaginateCreditGrantsQuery, {
          trace?: string;
      }>>

  • PaginateFormulationAttempts:function
    • PaginateFormulationAttempts(variables, options?): Promise<ExecutionResult<PaginateFormulationAttemptsQuery, {
          trace?: string;
      }>>

    • Parameters

      • variables: Exact<{
            before?: InputMaybe<string>;
            filter?: InputMaybe<AttemptFilter>;
            last: number;
            name: string;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<PaginateFormulationAttemptsQuery, {
          trace?: string;
      }>>

  • PaginateFormulationSpecifications:function
    • PaginateFormulationSpecifications(variables, options?): Promise<ExecutionResult<PaginateFormulationSpecificationsQuery, {
          trace?: string;
      }>>

    • Parameters

      • variables: Exact<{
            after?: InputMaybe<string>;
            before?: InputMaybe<string>;
            first?: InputMaybe<number>;
            formulationName: string;
            last?: InputMaybe<number>;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<PaginateFormulationSpecificationsQuery, {
          trace?: string;
      }>>

  • PaginateFormulationTags:function
    • PaginateFormulationTags(variables, options?): Promise<ExecutionResult<PaginateFormulationTagsQuery, {
          trace?: string;
      }>>

    • Parameters

      • variables: Exact<{
            after?: InputMaybe<string>;
            filter?: InputMaybe<FormulationTagsFilter>;
            first: number;
            formulationName: string;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<PaginateFormulationTagsQuery, {
          trace?: string;
      }>>

  • PaginateFormulations:function
    • PaginateFormulations(variables?, options?): Promise<ExecutionResult<PaginateFormulationsQuery, {
          trace?: string;
      }>>

    • Parameters

      • Optional variables: Exact<{
            after?: InputMaybe<string>;
            before?: InputMaybe<string>;
            filter?: InputMaybe<FormulationFilter>;
            first?: InputMaybe<number>;
            last?: InputMaybe<number>;
            orderBy?: InputMaybe<FormulationOrderBy>;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<PaginateFormulationsQuery, {
          trace?: string;
      }>>

  • PaginateQueuedSolveAttempts:function
    • PaginateQueuedSolveAttempts(variables?, options?): Promise<ExecutionResult<PaginateQueuedSolveAttemptsQuery, {
          trace?: string;
      }>>

    • Parameters

      • Optional variables: Exact<{
            after?: InputMaybe<string>;
            before?: InputMaybe<string>;
            filter?: InputMaybe<AttemptFilter>;
            first?: InputMaybe<number>;
            last?: InputMaybe<number>;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<PaginateQueuedSolveAttemptsQuery, {
          trace?: string;
      }>>

  • PaginateQueuedSolveNotifications:function
    • PaginateQueuedSolveNotifications(variables, options?): Promise<ExecutionResult<PaginateQueuedSolveNotificationsQuery, {
          trace?: string;
      }>>

    • Parameters

      • variables: Exact<{
            before?: InputMaybe<string>;
            last: number;
            uuid: string;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<PaginateQueuedSolveNotificationsQuery, {
          trace?: string;
      }>>

  • PollQueuedSolve:function
    • PollQueuedSolve(variables, options?): Promise<ExecutionResult<PollQueuedSolveQuery, {
          trace?: string;
      }>>

    • Parameters

      • variables: Exact<{
            uuid: string;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<PollQueuedSolveQuery, {
          trace?: string;
      }>>

  • RegisterSpecification:function
    • RegisterSpecification(variables, options?): Promise<ExecutionResult<RegisterSpecificationMutation, {
          trace?: string;
      }>>

    • Parameters

      • variables: Exact<{
            input: RegisterSpecificationInput;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<RegisterSpecificationMutation, {
          trace?: string;
      }>>

  • RevokeAuthorization:function
    • RevokeAuthorization(variables, options?): Promise<ExecutionResult<RevokeAuthorizationMutation, {
          trace?: string;
      }>>

    • Parameters

      • variables: Exact<{
            name: string;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<RevokeAuthorizationMutation, {
          trace?: string;
      }>>

  • UpdateFormulation:function
    • UpdateFormulation(variables, options?): Promise<ExecutionResult<UpdateFormulationMutation, {
          trace?: string;
      }>>

    • Parameters

      • variables: Exact<{
            input: UpdateFormulationInput;
        }>
      • Optional options: RequestOptions<((url, init?) => Promise<Response>)>

      Returns Promise<ExecutionResult<UpdateFormulationMutation, {
          trace?: string;
      }>>

Private Readonly sdk

sdk: SdkFor<operations, ((url, init?) => Promise<Response>)>

Type declaration

    • (url, init?): Promise<Response>

    • Parameters

      • url: URL | RequestInfo
      • Optional init: RequestInit

      Returns Promise<Response>

Private Readonly telemetry

telemetry: Telemetry

Methods

cancelSolve

deleteFormulation

  • deleteFormulation(name): Promise<boolean>

  • Deletes a formulation, returning true if a formulation was deleted.

    Parameters

    • name: string

    Returns Promise<boolean>

fetchFormulationOutline

  • fetchFormulationOutline(formulationName, tagName?): Promise<MarkPresent<FetchedOutlineFormulationFragment, "tag">>

  • Fetches a formulation's outline.

    Parameters

    • formulationName: string
    • Optional tagName: string

    Returns Promise<MarkPresent<FetchedOutlineFormulationFragment, "tag">>

fetchMember

fetchSolve

  • fetchSolve(uuid): Promise<undefined | FetchedQueuedSolveFragment>

  • Fetches a queued solve from its UUID.

    Parameters

    • uuid: string

    Returns Promise<undefined | FetchedQueuedSolveFragment>

fetchSolveInputs

  • fetchSolveInputs(uuid): Promise<{
        dimensions?: readonly {
            items: readonly (string | number)[];
            label: string;
        }[];
        parameters: readonly {
            defaultValue?: number | "Infinity" | "-Infinity";
            entries: readonly {
                key: readonly (string | number)[];
                value?: number | "Infinity" | "-Infinity";
            }[];
            label: string;
        }[];
    }>

  • Fetches an attempt's inputs from its UUID.

    Parameters

    • uuid: string

    Returns Promise<{
        dimensions?: readonly {
            items: readonly (string | number)[];
            label: string;
        }[];
        parameters: readonly {
            defaultValue?: number | "Infinity" | "-Infinity";
            entries: readonly {
                key: readonly (string | number)[];
                value?: number | "Infinity" | "-Infinity";
            }[];
            label: string;
        }[];
    }>

fetchSolveOutputs

  • fetchSolveOutputs(uuid): Promise<undefined | {
        constraints: readonly {
            entries: readonly {
                dualValue?: number;
                key: readonly (string | number)[];
                value: number;
            }[];
            label: string;
        }[];
        variables: readonly {
            entries: readonly {
                dualValue?: number;
                key: readonly (string | number)[];
                value: number;
            }[];
            label: string;
        }[];
    }>

  • Fetches an attempt's outputs from its UUID. This method will returned undefined if the attempt was not feasible.

    Parameters

    • uuid: string

    Returns Promise<undefined | {
        constraints: readonly {
            entries: readonly {
                dualValue?: number;
                key: readonly (string | number)[];
                value: number;
            }[];
            label: string;
        }[];
        variables: readonly {
            entries: readonly {
                dualValue?: number;
                key: readonly (string | number)[];
                value: number;
            }[];
            label: string;
        }[];
    }>

formatProblem

  • formatProblem(args): Readable

  • Returns an optimization model's underlying instructions.

    Parameters

    • args: {
          problem: {
              formulation: {
                  sources: readonly string[];
              } | {
                  name: string;
                  specificationTagName?: string;
              };
              inputs: {
                  dimensions?: readonly {
                      items: readonly (string | number)[];
                      label: string;
                  }[];
                  parameters: readonly {
                      defaultValue?: number | "Infinity" | "-Infinity";
                      entries: readonly {
                          key: readonly (string | number)[];
                          value?: number | "Infinity" | "-Infinity";
                      }[];
                      label: string;
                  }[];
              };
              options?: {
                  absoluteGapThreshold?: number;
                  freeBoundThreshold?: number;
                  infinityValueThreshold?: number;
                  relativeGapThreshold?: number;
                  timeoutMillis?: number;
                  zeroValueThreshold?: number;
              };
              strategy?: {
                  epsilonConstraints?: readonly {
                      absoluteTolerance?: number;
                      relativeTolerance?: number;
                      target: {
                          weights: readonly {
                              label: string;
                              value: number;
                              [key: string]: unknown;
                          }[];
                          [key: string]: unknown;
                      };
                      [key: string]: unknown;
                  }[];
                  isMaximization: boolean;
                  target: {
                      weights: readonly {
                          label: string;
                          value: number;
                          [key: string]: unknown;
                      }[];
                      [key: string]: unknown;
                  };
                  [key: string]: unknown;
              };
              transformations?: readonly ({
                  isCapped?: boolean;
                  kind: "relaxConstraint";
                  label: string;
                  penalty?: "TOTAL_DEVIATION" | "MAX_DEVIATION" | "DEVIATION_CARDINALITY";
              } | {
                  kind: "omitConstraint";
                  label: string;
              } | {
                  kind: "omitObjective";
                  label: string;
              } | {
                  kind: "pinVariable";
                  label: string;
              } | {
                  kind: "densifyVariable";
                  label: string;
              } | {
                  kind: "constrainObjective";
                  label: string;
                  maxValue?: number;
                  minValue?: number;
              })[];
          };
      }
      • Readonly problem: {
            formulation: {
                sources: readonly string[];
            } | {
                name: string;
                specificationTagName?: string;
            };
            inputs: {
                dimensions?: readonly {
                    items: readonly (string | number)[];
                    label: string;
                }[];
                parameters: readonly {
                    defaultValue?: number | "Infinity" | "-Infinity";
                    entries: readonly {
                        key: readonly (string | number)[];
                        value?: number | "Infinity" | "-Infinity";
                    }[];
                    label: string;
                }[];
            };
            options?: {
                absoluteGapThreshold?: number;
                freeBoundThreshold?: number;
                infinityValueThreshold?: number;
                relativeGapThreshold?: number;
                timeoutMillis?: number;
                zeroValueThreshold?: number;
            };
            strategy?: {
                epsilonConstraints?: readonly {
                    absoluteTolerance?: number;
                    relativeTolerance?: number;
                    target: {
                        weights: readonly {
                            label: string;
                            value: number;
                            [key: string]: unknown;
                        }[];
                        [key: string]: unknown;
                    };
                    [key: string]: unknown;
                }[];
                isMaximization: boolean;
                target: {
                    weights: readonly {
                        label: string;
                        value: number;
                        [key: string]: unknown;
                    }[];
                    [key: string]: unknown;
                };
                [key: string]: unknown;
            };
            transformations?: readonly ({
                isCapped?: boolean;
                kind: "relaxConstraint";
                label: string;
                penalty?: "TOTAL_DEVIATION" | "MAX_DEVIATION" | "DEVIATION_CARDINALITY";
            } | {
                kind: "omitConstraint";
                label: string;
            } | {
                kind: "omitObjective";
                label: string;
            } | {
                kind: "pinVariable";
                label: string;
            } | {
                kind: "densifyVariable";
                label: string;
            } | {
                kind: "constrainObjective";
                label: string;
                maxValue?: number;
                minValue?: number;
            })[];
        }
        • Readonly formulation: {
              sources: readonly string[];
          } | {
              name: string;
              specificationTagName?: string;
          }
        • Readonly inputs: {
              dimensions?: readonly {
                  items: readonly (string | number)[];
                  label: string;
              }[];
              parameters: readonly {
                  defaultValue?: number | "Infinity" | "-Infinity";
                  entries: readonly {
                      key: readonly (string | number)[];
                      value?: number | "Infinity" | "-Infinity";
                  }[];
                  label: string;
              }[];
          }
          • Optional Readonly dimensions?: readonly {
                items: readonly (string | number)[];
                label: string;
            }[]
          • Readonly parameters: readonly {
                defaultValue?: number | "Infinity" | "-Infinity";
                entries: readonly {
                    key: readonly (string | number)[];
                    value?: number | "Infinity" | "-Infinity";
                }[];
                label: string;
            }[]
        • Optional Readonly options?: {
              absoluteGapThreshold?: number;
              freeBoundThreshold?: number;
              infinityValueThreshold?: number;
              relativeGapThreshold?: number;
              timeoutMillis?: number;
              zeroValueThreshold?: number;
          }
          • Optional Readonly absoluteGapThreshold?: number

            Description

            Absolute gap threshold at which to consider a solution optimal

          • Optional Readonly freeBoundThreshold?: 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.

          • Optional Readonly infinityValueThreshold?: 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.

          • Optional Readonly relativeGapThreshold?: number

            Description

            Relative gap threshold at which to consider a solution optimal

          • Optional Readonly timeoutMillis?: number

            Description

            Upper bound on solving time. Note that the overall attempt time may be greater due to processing outside of the solve itself.

          • Optional Readonly zeroValueThreshold?: 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.

        • Optional Readonly strategy?: {
              epsilonConstraints?: readonly {
                  absoluteTolerance?: number;
                  relativeTolerance?: number;
                  target: {
                      weights: readonly {
                          label: string;
                          value: number;
                          [key: string]: unknown;
                      }[];
                      [key: string]: unknown;
                  };
                  [key: string]: unknown;
              }[];
              isMaximization: boolean;
              target: {
                  weights: readonly {
                      label: string;
                      value: number;
                      [key: string]: unknown;
                  }[];
                  [key: string]: unknown;
              };
              [key: string]: unknown;
          }
          • [key: string]: unknown
          • Optional Readonly epsilonConstraints?: readonly {
                absoluteTolerance?: number;
                relativeTolerance?: number;
                target: {
                    weights: readonly {
                        label: string;
                        value: number;
                        [key: string]: unknown;
                    }[];
                    [key: string]: unknown;
                };
                [key: string]: unknown;
            }[]
          • Readonly isMaximization: boolean
          • Readonly target: {
                weights: readonly {
                    label: string;
                    value: number;
                    [key: string]: unknown;
                }[];
                [key: string]: unknown;
            }
            • [key: string]: unknown
            • Readonly weights: readonly {
                  label: string;
                  value: number;
                  [key: string]: unknown;
              }[]
        • Optional Readonly transformations?: readonly ({
              isCapped?: boolean;
              kind: "relaxConstraint";
              label: string;
              penalty?: "TOTAL_DEVIATION" | "MAX_DEVIATION" | "DEVIATION_CARDINALITY";
          } | {
              kind: "omitConstraint";
              label: string;
          } | {
              kind: "omitObjective";
              label: string;
          } | {
              kind: "pinVariable";
              label: string;
          } | {
              kind: "densifyVariable";
              label: string;
          } | {
              kind: "constrainObjective";
              label: string;
              maxValue?: number;
              minValue?: number;
          })[]

    Returns Readable

generateAccessToken

  • generateAccessToken(input): Promise<string>

  • Creates a new access token for an authorization with the given name.

    Parameters

    • input: GenerateAuthorizationInput

    Returns Promise<string>

listAuthorizations

  • listAuthorizations(): Promise<readonly ListedAuthorizationFragment[]>

  • Lists all available authorizations.

    Returns Promise<readonly ListedAuthorizationFragment[]>

paginateAttempts

  • paginateAttempts(vars): Promise<Paginated<PaginatedAttemptFragment>>

  • Paginates available attempts.

    Parameters

    • vars: Exact<{
          after?: InputMaybe<string>;
          before?: InputMaybe<string>;
          filter?: InputMaybe<AttemptFilter>;
          first?: InputMaybe<number>;
          last?: InputMaybe<number>;
      }>

    Returns Promise<Paginated<PaginatedAttemptFragment>>

paginateCreditCharges

  • paginateCreditCharges(vars): Promise<Paginated<FullCreditChargeFragment>>

  • Paginates credit charges.

    Parameters

    • vars: Exact<{
          after?: InputMaybe<string>;
          before?: InputMaybe<string>;
          first?: InputMaybe<number>;
          last?: InputMaybe<number>;
      }>

    Returns Promise<Paginated<FullCreditChargeFragment>>

paginateCreditGrants

  • paginateCreditGrants(vars): Promise<Paginated<FullCreditGrantFragment>>

  • Paginates credit grants.

    Parameters

    • vars: Exact<{
          after?: InputMaybe<string>;
          before?: InputMaybe<string>;
          first?: InputMaybe<number>;
          last?: InputMaybe<number>;
      }>

    Returns Promise<Paginated<FullCreditGrantFragment>>

paginateFormulationTags

  • paginateFormulationTags(vars): Promise<Paginated<PaginatedFormulationTagFragment>>

  • Paginates available specification tags for a formulation.

    Parameters

    • vars: Exact<{
          after?: InputMaybe<string>;
          filter?: InputMaybe<FormulationTagsFilter>;
          first: number;
          formulationName: string;
      }>

    Returns Promise<Paginated<PaginatedFormulationTagFragment>>

paginateFormulations

  • paginateFormulations(vars): Promise<Paginated<PaginatedFormulationFragment>>

  • Paginates available formulations.

    Parameters

    • vars: Exact<{
          after?: InputMaybe<string>;
          before?: InputMaybe<string>;
          filter?: InputMaybe<FormulationFilter>;
          first?: InputMaybe<number>;
          last?: InputMaybe<number>;
          orderBy?: InputMaybe<FormulationOrderBy>;
      }>

    Returns Promise<Paginated<PaginatedFormulationFragment>>

paginateSolveNotifications

  • paginateSolveNotifications(vars): Promise<Paginated<FullSolveNotificationFragment>>

  • Paginates a queued solve's notifications.

    Parameters

    • vars: Exact<{
          before?: InputMaybe<string>;
          last: number;
          uuid: string;
      }>

    Returns Promise<Paginated<FullSolveNotificationFragment>>

parseSources

  • parseSources(args): Promise<{
        errors: readonly {
            code: string;
            index: number;
            isFatal: boolean;
            message: string;
            range: {
                end: {
                    column: number;
                    line: number;
                    offset: number;
                };
                start: {
                    column: number;
                    line: number;
                    offset: number;
                };
            };
        }[];
        outline?: {
            constraints: readonly {
                bindings: readonly {
                    dimensionLabel?: string;
                    qualifier?: string;
                }[];
                condition: "eq" | "geq" | "leq";
                derivation?: {
                    kind: "pinnedVariable";
                    label: string;
                } | {
                    kind: "relaxedConstraintCap";
                    label: string;
                    variant: "deficit" | "surplus";
                };
                label: string;
                subjects: readonly ({
                    kind: "parameter";
                    label: string;
                } | {
                    kind: "variable";
                    label: string;
                })[];
            }[];
            dimensions: readonly {
                isNumeric: boolean;
                label: string;
            }[];
            objectives: readonly {
                derivation?: {
                    kind: "relaxedConstraint";
                    label: string;
                    variant: "deficit" | "surplus";
                };
                isMaximization: boolean;
                isQuadratic: boolean;
                label: string;
            }[];
            parameters: readonly {
                bindings: readonly {
                    dimensionLabel?: string;
                    qualifier?: string;
                }[];
                derivation?: {
                    kind: "pinnedVariable";
                    label: string;
                } | {
                    kind: "relaxedConstraintCap";
                    label: string;
                    variant: "deficit" | "surplus";
                };
                image: {
                    isIntegral: boolean;
                    lowerBound: number | "Infinity" | "-Infinity" | "Dynamic";
                    upperBound: number | "Infinity" | "-Infinity" | "Dynamic";
                };
                label: string;
            }[];
            variables: readonly {
                bindings: readonly {
                    dimensionLabel?: string;
                    qualifier?: string;
                }[];
                derivation?: {
                    kind: "relaxedConstraint";
                    label: string;
                    variant: "deficit" | "surplus";
                };
                image: {
                    isIntegral: boolean;
                    lowerBound: number | "Infinity" | "-Infinity" | "Dynamic";
                    upperBound: number | "Infinity" | "-Infinity" | "Dynamic";
                };
                label: string;
            }[];
        };
        slices: readonly {
            definition: {
                category: "ALIAS" | "CONSTRAINT" | "DIMENSION" | "OBJECTIVE" | "PARAMETER" | "VARIABLE";
                label?: string;
                source: string;
            };
            index: number;
            range: {
                end: {
                    column: number;
                    line: number;
                    offset: number;
                };
                start: {
                    column: number;
                    line: number;
                    offset: number;
                };
            };
        }[];
    }>

  • Parses and validates a formulation's sources.

    Parameters

    • args: {
          includeOutline?: boolean;
          sources: readonly string[];
      }
      • Optional Readonly includeOutline?: boolean
      • Readonly sources: readonly string[]

    Returns Promise<{
        errors: readonly {
            code: string;
            index: number;
            isFatal: boolean;
            message: string;
            range: {
                end: {
                    column: number;
                    line: number;
                    offset: number;
                };
                start: {
                    column: number;
                    line: number;
                    offset: number;
                };
            };
        }[];
        outline?: {
            constraints: readonly {
                bindings: readonly {
                    dimensionLabel?: string;
                    qualifier?: string;
                }[];
                condition: "eq" | "geq" | "leq";
                derivation?: {
                    kind: "pinnedVariable";
                    label: string;
                } | {
                    kind: "relaxedConstraintCap";
                    label: string;
                    variant: "deficit" | "surplus";
                };
                label: string;
                subjects: readonly ({
                    kind: "parameter";
                    label: string;
                } | {
                    kind: "variable";
                    label: string;
                })[];
            }[];
            dimensions: readonly {
                isNumeric: boolean;
                label: string;
            }[];
            objectives: readonly {
                derivation?: {
                    kind: "relaxedConstraint";
                    label: string;
                    variant: "deficit" | "surplus";
                };
                isMaximization: boolean;
                isQuadratic: boolean;
                label: string;
            }[];
            parameters: readonly {
                bindings: readonly {
                    dimensionLabel?: string;
                    qualifier?: string;
                }[];
                derivation?: {
                    kind: "pinnedVariable";
                    label: string;
                } | {
                    kind: "relaxedConstraintCap";
                    label: string;
                    variant: "deficit" | "surplus";
                };
                image: {
                    isIntegral: boolean;
                    lowerBound: number | "Infinity" | "-Infinity" | "Dynamic";
                    upperBound: number | "Infinity" | "-Infinity" | "Dynamic";
                };
                label: string;
            }[];
            variables: readonly {
                bindings: readonly {
                    dimensionLabel?: string;
                    qualifier?: string;
                }[];
                derivation?: {
                    kind: "relaxedConstraint";
                    label: string;
                    variant: "deficit" | "surplus";
                };
                image: {
                    isIntegral: boolean;
                    lowerBound: number | "Infinity" | "-Infinity" | "Dynamic";
                    upperBound: number | "Infinity" | "-Infinity" | "Dynamic";
                };
                label: string;
            }[];
        };
        slices: readonly {
            definition: {
                category: "ALIAS" | "CONSTRAINT" | "DIMENSION" | "OBJECTIVE" | "PARAMETER" | "VARIABLE";
                label?: string;
                source: string;
            };
            index: number;
            range: {
                end: {
                    column: number;
                    line: number;
                    offset: number;
                };
                start: {
                    column: number;
                    line: number;
                    offset: number;
                };
            };
        }[];
    }>

queueSolve

  • queueSolve(args): Promise<{
        expiresAt: string;
        uuid: string;
        [key: string]: unknown;
    }>

  • Starts a new attempt. The attempt will run asynchronously; use the returned UUID to wait for its outcome (via waitForOutcome), fetch its inputs and outputs, etc.

    Parameters

    • args: {
          problem: {
              formulation: {
                  sources: readonly string[];
              } | {
                  name: string;
                  specificationTagName?: string;
              };
              inputs: {
                  dimensions?: readonly {
                      items: readonly (string | number)[];
                      label: string;
                  }[];
                  parameters: readonly {
                      defaultValue?: number | "Infinity" | "-Infinity";
                      entries: readonly {
                          key: readonly (string | number)[];
                          value?: number | "Infinity" | "-Infinity";
                      }[];
                      label: string;
                  }[];
              };
              options?: {
                  absoluteGapThreshold?: number;
                  freeBoundThreshold?: number;
                  infinityValueThreshold?: number;
                  relativeGapThreshold?: number;
                  timeoutMillis?: number;
                  zeroValueThreshold?: number;
              };
              strategy?: {
                  epsilonConstraints?: readonly {
                      absoluteTolerance?: number;
                      relativeTolerance?: number;
                      target: {
                          weights: readonly {
                              label: string;
                              value: number;
                              [key: string]: unknown;
                          }[];
                          [key: string]: unknown;
                      };
                      [key: string]: unknown;
                  }[];
                  isMaximization: boolean;
                  target: {
                      weights: readonly {
                          label: string;
                          value: number;
                          [key: string]: unknown;
                      }[];
                      [key: string]: unknown;
                  };
                  [key: string]: unknown;
              };
              transformations?: readonly ({
                  isCapped?: boolean;
                  kind: "relaxConstraint";
                  label: string;
                  penalty?: "TOTAL_DEVIATION" | "MAX_DEVIATION" | "DEVIATION_CARDINALITY";
              } | {
                  kind: "omitConstraint";
                  label: string;
              } | {
                  kind: "omitObjective";
                  label: string;
              } | {
                  kind: "pinVariable";
                  label: string;
              } | {
                  kind: "densifyVariable";
                  label: string;
              } | {
                  kind: "constrainObjective";
                  label: string;
                  maxValue?: number;
                  minValue?: number;
              })[];
          };
      }
      • Readonly problem: {
            formulation: {
                sources: readonly string[];
            } | {
                name: string;
                specificationTagName?: string;
            };
            inputs: {
                dimensions?: readonly {
                    items: readonly (string | number)[];
                    label: string;
                }[];
                parameters: readonly {
                    defaultValue?: number | "Infinity" | "-Infinity";
                    entries: readonly {
                        key: readonly (string | number)[];
                        value?: number | "Infinity" | "-Infinity";
                    }[];
                    label: string;
                }[];
            };
            options?: {
                absoluteGapThreshold?: number;
                freeBoundThreshold?: number;
                infinityValueThreshold?: number;
                relativeGapThreshold?: number;
                timeoutMillis?: number;
                zeroValueThreshold?: number;
            };
            strategy?: {
                epsilonConstraints?: readonly {
                    absoluteTolerance?: number;
                    relativeTolerance?: number;
                    target: {
                        weights: readonly {
                            label: string;
                            value: number;
                            [key: string]: unknown;
                        }[];
                        [key: string]: unknown;
                    };
                    [key: string]: unknown;
                }[];
                isMaximization: boolean;
                target: {
                    weights: readonly {
                        label: string;
                        value: number;
                        [key: string]: unknown;
                    }[];
                    [key: string]: unknown;
                };
                [key: string]: unknown;
            };
            transformations?: readonly ({
                isCapped?: boolean;
                kind: "relaxConstraint";
                label: string;
                penalty?: "TOTAL_DEVIATION" | "MAX_DEVIATION" | "DEVIATION_CARDINALITY";
            } | {
                kind: "omitConstraint";
                label: string;
            } | {
                kind: "omitObjective";
                label: string;
            } | {
                kind: "pinVariable";
                label: string;
            } | {
                kind: "densifyVariable";
                label: string;
            } | {
                kind: "constrainObjective";
                label: string;
                maxValue?: number;
                minValue?: number;
            })[];
        }
        • Readonly formulation: {
              sources: readonly string[];
          } | {
              name: string;
              specificationTagName?: string;
          }
        • Readonly inputs: {
              dimensions?: readonly {
                  items: readonly (string | number)[];
                  label: string;
              }[];
              parameters: readonly {
                  defaultValue?: number | "Infinity" | "-Infinity";
                  entries: readonly {
                      key: readonly (string | number)[];
                      value?: number | "Infinity" | "-Infinity";
                  }[];
                  label: string;
              }[];
          }
          • Optional Readonly dimensions?: readonly {
                items: readonly (string | number)[];
                label: string;
            }[]
          • Readonly parameters: readonly {
                defaultValue?: number | "Infinity" | "-Infinity";
                entries: readonly {
                    key: readonly (string | number)[];
                    value?: number | "Infinity" | "-Infinity";
                }[];
                label: string;
            }[]
        • Optional Readonly options?: {
              absoluteGapThreshold?: number;
              freeBoundThreshold?: number;
              infinityValueThreshold?: number;
              relativeGapThreshold?: number;
              timeoutMillis?: number;
              zeroValueThreshold?: number;
          }
          • Optional Readonly absoluteGapThreshold?: number

            Description

            Absolute gap threshold at which to consider a solution optimal

          • Optional Readonly freeBoundThreshold?: 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.

          • Optional Readonly infinityValueThreshold?: 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.

          • Optional Readonly relativeGapThreshold?: number

            Description

            Relative gap threshold at which to consider a solution optimal

          • Optional Readonly timeoutMillis?: number

            Description

            Upper bound on solving time. Note that the overall attempt time may be greater due to processing outside of the solve itself.

          • Optional Readonly zeroValueThreshold?: 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.

        • Optional Readonly strategy?: {
              epsilonConstraints?: readonly {
                  absoluteTolerance?: number;
                  relativeTolerance?: number;
                  target: {
                      weights: readonly {
                          label: string;
                          value: number;
                          [key: string]: unknown;
                      }[];
                      [key: string]: unknown;
                  };
                  [key: string]: unknown;
              }[];
              isMaximization: boolean;
              target: {
                  weights: readonly {
                      label: string;
                      value: number;
                      [key: string]: unknown;
                  }[];
                  [key: string]: unknown;
              };
              [key: string]: unknown;
          }
          • [key: string]: unknown
          • Optional Readonly epsilonConstraints?: readonly {
                absoluteTolerance?: number;
                relativeTolerance?: number;
                target: {
                    weights: readonly {
                        label: string;
                        value: number;
                        [key: string]: unknown;
                    }[];
                    [key: string]: unknown;
                };
                [key: string]: unknown;
            }[]
          • Readonly isMaximization: boolean
          • Readonly target: {
                weights: readonly {
                    label: string;
                    value: number;
                    [key: string]: unknown;
                }[];
                [key: string]: unknown;
            }
            • [key: string]: unknown
            • Readonly weights: readonly {
                  label: string;
                  value: number;
                  [key: string]: unknown;
              }[]
        • Optional Readonly transformations?: readonly ({
              isCapped?: boolean;
              kind: "relaxConstraint";
              label: string;
              penalty?: "TOTAL_DEVIATION" | "MAX_DEVIATION" | "DEVIATION_CARDINALITY";
          } | {
              kind: "omitConstraint";
              label: string;
          } | {
              kind: "omitObjective";
              label: string;
          } | {
              kind: "pinVariable";
              label: string;
          } | {
              kind: "densifyVariable";
              label: string;
          } | {
              kind: "constrainObjective";
              label: string;
              maxValue?: number;
              minValue?: number;
          })[]

    Returns Promise<{
        expiresAt: string;
        uuid: string;
        [key: string]: unknown;
    }>

registerSpecification

  • registerSpecification(input): Promise<RegisteredSpecificationFragment>

  • Adds a new specification.

    Parameters

    • input: RegisterSpecificationInput

    Returns Promise<RegisteredSpecificationFragment>

revokeAuthorization

  • revokeAuthorization(name): Promise<boolean>

  • Revokes an authorization from its name, returning true if one existed.

    Parameters

    • name: string

    Returns Promise<boolean>

runSolve

  • runSolve(args): SolveTracker

  • Solves an optimization model.

    Parameters

    • args: {
          problem: {
              formulation: {
                  sources: readonly string[];
              } | {
                  name: string;
                  specificationTagName?: string;
              };
              inputs: {
                  dimensions?: readonly {
                      items: readonly (string | number)[];
                      label: string;
                  }[];
                  parameters: readonly {
                      defaultValue?: number | "Infinity" | "-Infinity";
                      entries: readonly {
                          key: readonly (string | number)[];
                          value?: number | "Infinity" | "-Infinity";
                      }[];
                      label: string;
                  }[];
              };
              options?: {
                  absoluteGapThreshold?: number;
                  freeBoundThreshold?: number;
                  infinityValueThreshold?: number;
                  relativeGapThreshold?: number;
                  timeoutMillis?: number;
                  zeroValueThreshold?: number;
              };
              strategy?: {
                  epsilonConstraints?: readonly {
                      absoluteTolerance?: number;
                      relativeTolerance?: number;
                      target: {
                          weights: readonly {
                              label: string;
                              value: number;
                              [key: string]: unknown;
                          }[];
                          [key: string]: unknown;
                      };
                      [key: string]: unknown;
                  }[];
                  isMaximization: boolean;
                  target: {
                      weights: readonly {
                          label: string;
                          value: number;
                          [key: string]: unknown;
                      }[];
                      [key: string]: unknown;
                  };
                  [key: string]: unknown;
              };
              transformations?: readonly ({
                  isCapped?: boolean;
                  kind: "relaxConstraint";
                  label: string;
                  penalty?: "TOTAL_DEVIATION" | "MAX_DEVIATION" | "DEVIATION_CARDINALITY";
              } | {
                  kind: "omitConstraint";
                  label: string;
              } | {
                  kind: "omitObjective";
                  label: string;
              } | {
                  kind: "pinVariable";
                  label: string;
              } | {
                  kind: "densifyVariable";
                  label: string;
              } | {
                  kind: "constrainObjective";
                  label: string;
                  maxValue?: number;
                  minValue?: number;
              })[];
          };
      }
      • Readonly problem: {
            formulation: {
                sources: readonly string[];
            } | {
                name: string;
                specificationTagName?: string;
            };
            inputs: {
                dimensions?: readonly {
                    items: readonly (string | number)[];
                    label: string;
                }[];
                parameters: readonly {
                    defaultValue?: number | "Infinity" | "-Infinity";
                    entries: readonly {
                        key: readonly (string | number)[];
                        value?: number | "Infinity" | "-Infinity";
                    }[];
                    label: string;
                }[];
            };
            options?: {
                absoluteGapThreshold?: number;
                freeBoundThreshold?: number;
                infinityValueThreshold?: number;
                relativeGapThreshold?: number;
                timeoutMillis?: number;
                zeroValueThreshold?: number;
            };
            strategy?: {
                epsilonConstraints?: readonly {
                    absoluteTolerance?: number;
                    relativeTolerance?: number;
                    target: {
                        weights: readonly {
                            label: string;
                            value: number;
                            [key: string]: unknown;
                        }[];
                        [key: string]: unknown;
                    };
                    [key: string]: unknown;
                }[];
                isMaximization: boolean;
                target: {
                    weights: readonly {
                        label: string;
                        value: number;
                        [key: string]: unknown;
                    }[];
                    [key: string]: unknown;
                };
                [key: string]: unknown;
            };
            transformations?: readonly ({
                isCapped?: boolean;
                kind: "relaxConstraint";
                label: string;
                penalty?: "TOTAL_DEVIATION" | "MAX_DEVIATION" | "DEVIATION_CARDINALITY";
            } | {
                kind: "omitConstraint";
                label: string;
            } | {
                kind: "omitObjective";
                label: string;
            } | {
                kind: "pinVariable";
                label: string;
            } | {
                kind: "densifyVariable";
                label: string;
            } | {
                kind: "constrainObjective";
                label: string;
                maxValue?: number;
                minValue?: number;
            })[];
        }
        • Readonly formulation: {
              sources: readonly string[];
          } | {
              name: string;
              specificationTagName?: string;
          }
        • Readonly inputs: {
              dimensions?: readonly {
                  items: readonly (string | number)[];
                  label: string;
              }[];
              parameters: readonly {
                  defaultValue?: number | "Infinity" | "-Infinity";
                  entries: readonly {
                      key: readonly (string | number)[];
                      value?: number | "Infinity" | "-Infinity";
                  }[];
                  label: string;
              }[];
          }
          • Optional Readonly dimensions?: readonly {
                items: readonly (string | number)[];
                label: string;
            }[]
          • Readonly parameters: readonly {
                defaultValue?: number | "Infinity" | "-Infinity";
                entries: readonly {
                    key: readonly (string | number)[];
                    value?: number | "Infinity" | "-Infinity";
                }[];
                label: string;
            }[]
        • Optional Readonly options?: {
              absoluteGapThreshold?: number;
              freeBoundThreshold?: number;
              infinityValueThreshold?: number;
              relativeGapThreshold?: number;
              timeoutMillis?: number;
              zeroValueThreshold?: number;
          }
          • Optional Readonly absoluteGapThreshold?: number

            Description

            Absolute gap threshold at which to consider a solution optimal

          • Optional Readonly freeBoundThreshold?: 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.

          • Optional Readonly infinityValueThreshold?: 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.

          • Optional Readonly relativeGapThreshold?: number

            Description

            Relative gap threshold at which to consider a solution optimal

          • Optional Readonly timeoutMillis?: number

            Description

            Upper bound on solving time. Note that the overall attempt time may be greater due to processing outside of the solve itself.

          • Optional Readonly zeroValueThreshold?: 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.

        • Optional Readonly strategy?: {
              epsilonConstraints?: readonly {
                  absoluteTolerance?: number;
                  relativeTolerance?: number;
                  target: {
                      weights: readonly {
                          label: string;
                          value: number;
                          [key: string]: unknown;
                      }[];
                      [key: string]: unknown;
                  };
                  [key: string]: unknown;
              }[];
              isMaximization: boolean;
              target: {
                  weights: readonly {
                      label: string;
                      value: number;
                      [key: string]: unknown;
                  }[];
                  [key: string]: unknown;
              };
              [key: string]: unknown;
          }
          • [key: string]: unknown
          • Optional Readonly epsilonConstraints?: readonly {
                absoluteTolerance?: number;
                relativeTolerance?: number;
                target: {
                    weights: readonly {
                        label: string;
                        value: number;
                        [key: string]: unknown;
                    }[];
                    [key: string]: unknown;
                };
                [key: string]: unknown;
            }[]
          • Readonly isMaximization: boolean
          • Readonly target: {
                weights: readonly {
                    label: string;
                    value: number;
                    [key: string]: unknown;
                }[];
                [key: string]: unknown;
            }
            • [key: string]: unknown
            • Readonly weights: readonly {
                  label: string;
                  value: number;
                  [key: string]: unknown;
              }[]
        • Optional Readonly transformations?: readonly ({
              isCapped?: boolean;
              kind: "relaxConstraint";
              label: string;
              penalty?: "TOTAL_DEVIATION" | "MAX_DEVIATION" | "DEVIATION_CARDINALITY";
          } | {
              kind: "omitConstraint";
              label: string;
          } | {
              kind: "omitObjective";
              label: string;
          } | {
              kind: "pinVariable";
              label: string;
          } | {
              kind: "densifyVariable";
              label: string;
          } | {
              kind: "constrainObjective";
              label: string;
              maxValue?: number;
              minValue?: number;
          })[]

    Returns SolveTracker

trackSolve

  • trackSolve(uuid): QueuedSolveTracker

  • Tracks a queued solve until its outcome is decided, emitting it as 'outcome'. 'notification' events will periodically be emitted containing the attempt's latest progress. If the attempt faile , the event emitter will emit an error.

    Parameters

    • uuid: string

    Returns QueuedSolveTracker

updateFormulation

  • updateFormulation(input): Promise<UpdatedFormulationFragment>

  • Updates a formulation's metadata.

    Parameters

    • input: UpdateFormulationInput

    Returns Promise<UpdatedFormulationFragment>

waitForOutcome

  • waitForOutcome(uuid): Promise<{
        objectiveValue?: number;
        relativeGap?: number | "Infinity" | "-Infinity";
        status: "UNKNOWN" | "INFEASIBLE" | "UNBOUNDED" | "FEASIBLE" | "OPTIMAL" | "ABORTED";
        [key: string]: unknown;
    }>

  • Convenience method which resolves when the attempt is solved. Consider using trackSolve to get access to progress notifications and other statuses.

    Parameters

    • uuid: string

    Returns Promise<{
        objectiveValue?: number;
        relativeGap?: number | "Infinity" | "-Infinity";
        status: "UNKNOWN" | "INFEASIBLE" | "UNBOUNDED" | "FEASIBLE" | "OPTIMAL" | "ABORTED";
        [key: string]: unknown;
    }>

Static create

Settings

Member Visibility

Theme

On This Page

constructorapiEndpointauthenticatedgraphqlSdksdktelemetrycancelSolvedeleteFormulationfetchFormulationOutlinefetchMemberfetchSolvefetchSolveInputsfetchSolveOutputsformatProblemgenerateAccessTokenlistAuthorizationspaginateAttemptspaginateCreditChargespaginateCreditGrantspaginateFormulationTagspaginateFormulationspaginateSolveNotificationsparseSourcesqueueSolveregisterSpecificationrevokeAuthorizationrunSolvetrackSolveupdateFormulationwaitForOutcomecreate