Class OpviousClient

Opvious API client.

Hierarchy

  • OpviousClient

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 shareFormulation trackSolve unshareFormulation updateFormulation waitForOutcome create

Constructors

Private constructor

  • 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;
          }>>;
          PaginateQueuedSolveNotifications(variables, options?) => Promise<ExecutionResult<PaginateQueuedSolveNotificationsQuery, {
              trace?: string;
          }>>;
          PaginateSharedSpecificationTags(variables, options?) => Promise<ExecutionResult<PaginateSharedSpecificationTagsQuery, {
              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;
          }>>;
          StartSharingFormulation(variables, options?) => Promise<ExecutionResult<StartSharingFormulationMutation, {
              trace?: string;
          }>>;
          StopSharingFormulation(variables, options?) => Promise<ExecutionResult<StopSharingFormulationMutation, {
              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>;
                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;
          }>>

      • 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;
          }>>

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

        • Parameters

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

          Returns Promise<ExecutionResult<PaginateSharedSpecificationTagsQuery, {
              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;
          }>>

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

        • Parameters

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

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

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

        • Parameters

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

          Returns Promise<ExecutionResult<StopSharingFormulationMutation, {
              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;
    }>>;
    PaginateQueuedSolveNotifications(variables, options?) => Promise<ExecutionResult<PaginateQueuedSolveNotificationsQuery, {
        trace?: string;
    }>>;
    PaginateSharedSpecificationTags(variables, options?) => Promise<ExecutionResult<PaginateSharedSpecificationTagsQuery, {
        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;
    }>>;
    StartSharingFormulation(variables, options?) => Promise<ExecutionResult<StartSharingFormulationMutation, {
        trace?: string;
    }>>;
    StopSharingFormulation(variables, options?) => Promise<ExecutionResult<StopSharingFormulationMutation, {
        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>;
            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;
      }>>

  • 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;
      }>>

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

    • Parameters

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

      Returns Promise<ExecutionResult<PaginateSharedSpecificationTagsQuery, {
          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;
      }>>

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

    • Parameters

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

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

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

    • Parameters

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

      Returns Promise<ExecutionResult<StopSharingFormulationMutation, {
          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>)>

Private Readonly telemetry

telemetry: Telemetry

Methods

cancelSolve

deleteFormulation

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

    Parameters

    • name: string

    Returns Promise<boolean>

fetchFormulationOutline

  • Fetches a formulation's outline.

    Parameters

    • formulationName: string
    • Optional tagName: string

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

fetchMember

fetchSolve

  • Fetches a queued solve from its UUID.

    Parameters

    • uuid: string

    Returns Promise<undefined | FetchedQueuedSolveFragment>

fetchSolveInputs

  • 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 { readonly key: readonly (string | number)[]; readonly value?: number | "Infinity" | "-Infinity" | undefined; }[];
            label: string;
        }[];
    }>

fetchSolveOutputs

  • 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 { readonly key: readonly (string | number)[]; readonly value: number; readonly dualValue?: number | undefined; }[];
            label: string;
        }[];
        variables: readonly {
            entries: readonly { readonly key: readonly (string | number)[]; readonly value: number; readonly dualValue?: number | undefined; }[];
            label: string;
        }[];
    }>

formatProblem

  • 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 { readonly key: readonly (string | number)[]; readonly value?: number | "Infinity" | "-Infinity" | undefined; }[];
                      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 { [key: string]: unknown; readonly label: string; readonly value: number; }[];
                          [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 { readonly key: readonly (string | number)[]; readonly value?: number | "Infinity" | "-Infinity" | undefined; }[];
                    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 { [key: string]: unknown; readonly label: string; readonly value: number; }[];
                        [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 { readonly key: readonly (string | number)[]; readonly value?: number | "Infinity" | "-Infinity" | undefined; }[];
                  label: string;
              }[];
          }
          • Optional Readonly dimensions?: readonly {
                items: readonly (string | number)[];
                label: string;
            }[]
          • Readonly parameters: readonly {
                defaultValue?: number | "Infinity" | "-Infinity";
                entries: readonly { readonly key: readonly (string | number)[]; readonly value?: number | "Infinity" | "-Infinity" | undefined; }[];
                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 { [key: string]: unknown; readonly label: string; readonly value: number; }[];
                      [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 { [key: string]: unknown; readonly label: string; readonly value: number; }[];
                    [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

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

    Parameters

    • input: GenerateAuthorizationInput

    Returns Promise<string>

listAuthorizations

  • Lists all available authorizations.

    Returns Promise<readonly ListedAuthorizationFragment[]>

paginateAttempts

  • 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

  • Paginates credit charges.

    Parameters

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

    Returns Promise<Paginated<FullCreditChargeFragment>>

paginateCreditGrants

  • Paginates credit grants.

    Parameters

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

    Returns Promise<Paginated<FullCreditGrantFragment>>

paginateFormulationTags

  • 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

  • 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

  • Paginates a queued solve's notifications.

    Parameters

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

    Returns Promise<Paginated<FullSolveNotificationFragment>>

parseSources

  • 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 { readonly dimensionLabel?: string | undefined; readonly qualifier?: string | undefined; }[];
                condition: "eq" | "geq" | "leq";
                derivation?: {
                    kind: "pinnedVariable";
                    label: string;
                } | {
                    kind: "relaxedConstraintCap";
                    label: string;
                    variant: "deficit" | "surplus";
                };
                label: string;
                subjects: readonly ({ readonly kind: "parameter"; readonly label: string; } | { readonly kind: "variable"; readonly 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 { readonly dimensionLabel?: string | undefined; readonly qualifier?: string | undefined; }[];
                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 { readonly dimensionLabel?: string | undefined; readonly qualifier?: string | undefined; }[];
                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

  • 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 { readonly key: readonly (string | number)[]; readonly value?: number | "Infinity" | "-Infinity" | undefined; }[];
                      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 { [key: string]: unknown; readonly label: string; readonly value: number; }[];
                          [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 { readonly key: readonly (string | number)[]; readonly value?: number | "Infinity" | "-Infinity" | undefined; }[];
                    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 { [key: string]: unknown; readonly label: string; readonly value: number; }[];
                        [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 { readonly key: readonly (string | number)[]; readonly value?: number | "Infinity" | "-Infinity" | undefined; }[];
                  label: string;
              }[];
          }
          • Optional Readonly dimensions?: readonly {
                items: readonly (string | number)[];
                label: string;
            }[]
          • Readonly parameters: readonly {
                defaultValue?: number | "Infinity" | "-Infinity";
                entries: readonly { readonly key: readonly (string | number)[]; readonly value?: number | "Infinity" | "-Infinity" | undefined; }[];
                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 { [key: string]: unknown; readonly label: string; readonly value: number; }[];
                      [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 { [key: string]: unknown; readonly label: string; readonly value: number; }[];
                    [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

  • Adds a new specification.

    Parameters

    • input: RegisterSpecificationInput

    Returns Promise<RegisteredSpecificationFragment>

revokeAuthorization

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

    Parameters

    • name: string

    Returns Promise<boolean>

runSolve

  • 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 { readonly key: readonly (string | number)[]; readonly value?: number | "Infinity" | "-Infinity" | undefined; }[];
                      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 { [key: string]: unknown; readonly label: string; readonly value: number; }[];
                          [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 { readonly key: readonly (string | number)[]; readonly value?: number | "Infinity" | "-Infinity" | undefined; }[];
                    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 { [key: string]: unknown; readonly label: string; readonly value: number; }[];
                        [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 { readonly key: readonly (string | number)[]; readonly value?: number | "Infinity" | "-Infinity" | undefined; }[];
                  label: string;
              }[];
          }
          • Optional Readonly dimensions?: readonly {
                items: readonly (string | number)[];
                label: string;
            }[]
          • Readonly parameters: readonly {
                defaultValue?: number | "Infinity" | "-Infinity";
                entries: readonly { readonly key: readonly (string | number)[]; readonly value?: number | "Infinity" | "-Infinity" | undefined; }[];
                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 { [key: string]: unknown; readonly label: string; readonly value: number; }[];
                      [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 { [key: string]: unknown; readonly label: string; readonly value: number; }[];
                    [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

shareFormulation

  • Makes a formulation's tag publicly accessible via a unique URL. This can be disabled via unshareFormulation.

    Parameters

    • input: StartSharingFormulationInput

    Returns Promise<MarkPresent<SharedSpecificationTagFragment, "sharedVia">>

trackSolve

  • 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

unshareFormulation

  • Makes a formulation's tag(s) private. If not tags are specified, all the formulations tags will be set to private.

    Parameters

    • input: StopSharingFormulationInput

    Returns Promise<UnsharedFormulationFragment>

updateFormulation

  • Updates a formulation's metadata.

    Parameters

    • input: UpdateFormulationInput

    Returns Promise<UpdatedFormulationFragment>

waitForOutcome

  • 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

Generated using TypeDoc