// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.

import * as Errors from './error';
import * as Uploads from './uploads';
import { type Agent } from './_shims/index';
import * as Core from './core';
import * as API from './resources/index';

export interface ClientOptions {
  /**
   * Override the default base URL for the API, e.g., "https://api.example.com/v2/"
   *
   * Defaults to process.env['ENDEX_PREFECT_DEV_BASE_URL'].
   */
  baseURL?: string | null | undefined;

  /**
   * The maximum amount of time (in milliseconds) that the client should wait for a response
   * from the server before timing out a single request.
   *
   * Note that request timeouts are retried by default, so in a worst-case scenario you may wait
   * much longer than this timeout before the promise succeeds or fails.
   */
  timeout?: number;

  /**
   * An HTTP agent used to manage HTTP(S) connections.
   *
   * If not provided, an agent will be constructed by default in the Node.js environment,
   * otherwise no agent is used.
   */
  httpAgent?: Agent;

  /**
   * Specify a custom `fetch` function implementation.
   *
   * If not provided, we use `node-fetch` on Node.js and otherwise expect that `fetch` is
   * defined globally.
   */
  fetch?: Core.Fetch | undefined;

  /**
   * The maximum number of times that the client will retry a request in case of a
   * temporary failure, like a network error or a 5XX error from the server.
   *
   * @default 2
   */
  maxRetries?: number;

  /**
   * Default headers to include with every request to the API.
   *
   * These can be removed in individual requests by explicitly setting the
   * header to `undefined` or `null` in request options.
   */
  defaultHeaders?: Core.Headers;

  /**
   * Default query parameters to include with every request to the API.
   *
   * These can be removed in individual requests by explicitly setting the
   * param to `undefined` in request options.
   */
  defaultQuery?: Core.DefaultQuery;
}

/**
 * API Client for interfacing with the Endex Prefect Dev API.
 */
export class EndexPrefectDev extends Core.APIClient {
  private _options: ClientOptions;

  /**
   * API Client for interfacing with the Endex Prefect Dev API.
   *
   * @param {string} [opts.baseURL=process.env['ENDEX_PREFECT_DEV_BASE_URL'] ?? https://localhost:8080/test-api] - Override the default base URL for the API.
   * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
   * @param {number} [opts.httpAgent] - An HTTP agent used to manage HTTP(s) connections.
   * @param {Core.Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
   * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
   * @param {Core.Headers} opts.defaultHeaders - Default headers to include with every request to the API.
   * @param {Core.DefaultQuery} opts.defaultQuery - Default query parameters to include with every request to the API.
   */
  constructor({ baseURL = Core.readEnv('ENDEX_PREFECT_DEV_BASE_URL'), ...opts }: ClientOptions = {}) {
    const options: ClientOptions = {
      ...opts,
      baseURL: baseURL || `https://localhost:8080/test-api`,
    };

    super({
      baseURL: options.baseURL!,
      timeout: options.timeout ?? 60000 /* 1 minute */,
      httpAgent: options.httpAgent,
      maxRetries: options.maxRetries,
      fetch: options.fetch,
    });

    this._options = options;
  }

  admin: API.Admin = new API.Admin(this);
  artifacts: API.Artifacts = new API.Artifacts(this);
  automations: API.Automations = new API.Automations(this);
  blockCapabilities: API.BlockCapabilities = new API.BlockCapabilities(this);
  blockDocuments: API.BlockDocuments = new API.BlockDocuments(this);
  blockSchemas: API.BlockSchemas = new API.BlockSchemas(this);
  blockTypes: API.BlockTypes = new API.BlockTypes(this);
  collections: API.Collections = new API.Collections(this);
  concurrencyLimits: API.ConcurrencyLimits = new API.ConcurrencyLimits(this);
  csrfTokens: API.CsrfTokens = new API.CsrfTokens(this);
  deployments: API.Deployments = new API.Deployments(this);
  events: API.Events = new API.Events(this);
  flowRunNotificationPolicies: API.FlowRunNotificationPolicies = new API.FlowRunNotificationPolicies(this);
  flowRunStates: API.FlowRunStates = new API.FlowRunStates(this);
  flowRuns: API.FlowRuns = new API.FlowRuns(this);
  flows: API.Flows = new API.Flows(this);
  root: API.Root = new API.Root(this);
  logs: API.Logs = new API.Logs(this);
  savedSearches: API.SavedSearches = new API.SavedSearches(this);
  taskRunStates: API.TaskRunStates = new API.TaskRunStates(this);
  taskRuns: API.TaskRuns = new API.TaskRuns(this);
  taskWorkers: API.TaskWorkers = new API.TaskWorkers(this);
  ui: API.Ui = new API.Ui(this);
  concurrencyLimitsV2: API.ConcurrencyLimitsV2 = new API.ConcurrencyLimitsV2(this);
  variables: API.Variables = new API.Variables(this);
  workPools: API.WorkPools = new API.WorkPools(this);
  workQueues: API.WorkQueues = new API.WorkQueues(this);

  protected override defaultQuery(): Core.DefaultQuery | undefined {
    return this._options.defaultQuery;
  }

  protected override defaultHeaders(opts: Core.FinalRequestOptions): Core.Headers {
    return {
      ...super.defaultHeaders(opts),
      ...this._options.defaultHeaders,
    };
  }

  static EndexPrefectDev = this;
  static DEFAULT_TIMEOUT = 60000; // 1 minute

  static EndexPrefectDevError = Errors.EndexPrefectDevError;
  static APIError = Errors.APIError;
  static APIConnectionError = Errors.APIConnectionError;
  static APIConnectionTimeoutError = Errors.APIConnectionTimeoutError;
  static APIUserAbortError = Errors.APIUserAbortError;
  static NotFoundError = Errors.NotFoundError;
  static ConflictError = Errors.ConflictError;
  static RateLimitError = Errors.RateLimitError;
  static BadRequestError = Errors.BadRequestError;
  static AuthenticationError = Errors.AuthenticationError;
  static InternalServerError = Errors.InternalServerError;
  static PermissionDeniedError = Errors.PermissionDeniedError;
  static UnprocessableEntityError = Errors.UnprocessableEntityError;

  static toFile = Uploads.toFile;
  static fileFromPath = Uploads.fileFromPath;
}

export const {
  EndexPrefectDevError,
  APIError,
  APIConnectionError,
  APIConnectionTimeoutError,
  APIUserAbortError,
  NotFoundError,
  ConflictError,
  RateLimitError,
  BadRequestError,
  AuthenticationError,
  InternalServerError,
  PermissionDeniedError,
  UnprocessableEntityError,
} = Errors;

export import toFile = Uploads.toFile;
export import fileFromPath = Uploads.fileFromPath;

export namespace EndexPrefectDev {
  export import RequestOptions = Core.RequestOptions;

  export import Admin = API.Admin;

  export import Artifacts = API.Artifacts;
  export import Artifact = API.Artifact;
  export import ArtifactCountResponse = API.ArtifactCountResponse;
  export import ArtifactFilterResponse = API.ArtifactFilterResponse;
  export import ArtifactCreateParams = API.ArtifactCreateParams;
  export import ArtifactRetrieveParams = API.ArtifactRetrieveParams;
  export import ArtifactUpdateParams = API.ArtifactUpdateParams;
  export import ArtifactDeleteParams = API.ArtifactDeleteParams;
  export import ArtifactCountParams = API.ArtifactCountParams;
  export import ArtifactFilterParams = API.ArtifactFilterParams;

  export import Automations = API.Automations;
  export import Automation = API.Automation;
  export import AutomationCountResponse = API.AutomationCountResponse;
  export import AutomationFilterResponse = API.AutomationFilterResponse;
  export import AutomationCreateParams = API.AutomationCreateParams;
  export import AutomationRetrieveParams = API.AutomationRetrieveParams;
  export import AutomationUpdateParams = API.AutomationUpdateParams;
  export import AutomationDeleteParams = API.AutomationDeleteParams;
  export import AutomationCountParams = API.AutomationCountParams;
  export import AutomationFilterParams = API.AutomationFilterParams;

  export import BlockCapabilities = API.BlockCapabilities;
  export import BlockCapabilityListResponse = API.BlockCapabilityListResponse;
  export import BlockCapabilityListParams = API.BlockCapabilityListParams;

  export import BlockDocuments = API.BlockDocuments;
  export import BlockDocumentCountResponse = API.BlockDocumentCountResponse;
  export import BlockDocumentFilterResponse = API.BlockDocumentFilterResponse;
  export import BlockDocumentCreateParams = API.BlockDocumentCreateParams;
  export import BlockDocumentRetrieveParams = API.BlockDocumentRetrieveParams;
  export import BlockDocumentUpdateParams = API.BlockDocumentUpdateParams;
  export import BlockDocumentDeleteParams = API.BlockDocumentDeleteParams;
  export import BlockDocumentCountParams = API.BlockDocumentCountParams;
  export import BlockDocumentFilterParams = API.BlockDocumentFilterParams;

  export import BlockSchemas = API.BlockSchemas;
  export import BlockSchema = API.BlockSchema;
  export import BlockSchemaFilterResponse = API.BlockSchemaFilterResponse;
  export import BlockSchemaCreateParams = API.BlockSchemaCreateParams;
  export import BlockSchemaRetrieveParams = API.BlockSchemaRetrieveParams;
  export import BlockSchemaDeleteParams = API.BlockSchemaDeleteParams;
  export import BlockSchemaFilterParams = API.BlockSchemaFilterParams;

  export import BlockTypes = API.BlockTypes;
  export import BlockType = API.BlockType;
  export import BlockTypeFilterResponse = API.BlockTypeFilterResponse;
  export import BlockTypeInstallSystemBlockTypesResponse = API.BlockTypeInstallSystemBlockTypesResponse;
  export import BlockTypeCreateParams = API.BlockTypeCreateParams;
  export import BlockTypeRetrieveParams = API.BlockTypeRetrieveParams;
  export import BlockTypeUpdateParams = API.BlockTypeUpdateParams;
  export import BlockTypeDeleteParams = API.BlockTypeDeleteParams;
  export import BlockTypeFilterParams = API.BlockTypeFilterParams;
  export import BlockTypeInstallSystemBlockTypesParams = API.BlockTypeInstallSystemBlockTypesParams;

  export import Collections = API.Collections;

  export import ConcurrencyLimits = API.ConcurrencyLimits;
  export import ConcurrencyLimitDeleteResponse = API.ConcurrencyLimitDeleteResponse;
  export import ConcurrencyLimitDecrementResponse = API.ConcurrencyLimitDecrementResponse;
  export import ConcurrencyLimitFilterResponse = API.ConcurrencyLimitFilterResponse;
  export import ConcurrencyLimitIncrementResponse = API.ConcurrencyLimitIncrementResponse;
  export import ConcurrencyLimitCreateParams = API.ConcurrencyLimitCreateParams;
  export import ConcurrencyLimitRetrieveParams = API.ConcurrencyLimitRetrieveParams;
  export import ConcurrencyLimitDeleteParams = API.ConcurrencyLimitDeleteParams;
  export import ConcurrencyLimitDecrementParams = API.ConcurrencyLimitDecrementParams;
  export import ConcurrencyLimitFilterParams = API.ConcurrencyLimitFilterParams;
  export import ConcurrencyLimitIncrementParams = API.ConcurrencyLimitIncrementParams;

  export import CsrfTokens = API.CsrfTokens;
  export import CsrfToken = API.CsrfToken;
  export import CsrfTokenUpdateParams = API.CsrfTokenUpdateParams;

  export import Deployments = API.Deployments;
  export import DeploymentPaginationResponse = API.DeploymentPaginationResponse;
  export import DeploymentResponse = API.DeploymentResponse;
  export import DeploymentSchedule = API.DeploymentSchedule;
  export import WorkQueue = API.WorkQueue;
  export import DeploymentCountResponse = API.DeploymentCountResponse;
  export import DeploymentFilterResponse = API.DeploymentFilterResponse;
  export import DeploymentGetScheduledFlowRunsResponse = API.DeploymentGetScheduledFlowRunsResponse;
  export import DeploymentPauseDeploymentResponse = API.DeploymentPauseDeploymentResponse;
  export import DeploymentResumeDeploymentResponse = API.DeploymentResumeDeploymentResponse;
  export import DeploymentCreateParams = API.DeploymentCreateParams;
  export import DeploymentRetrieveParams = API.DeploymentRetrieveParams;
  export import DeploymentUpdateParams = API.DeploymentUpdateParams;
  export import DeploymentDeleteParams = API.DeploymentDeleteParams;
  export import DeploymentCountParams = API.DeploymentCountParams;
  export import DeploymentFilterParams = API.DeploymentFilterParams;
  export import DeploymentGetScheduledFlowRunsParams = API.DeploymentGetScheduledFlowRunsParams;
  export import DeploymentPaginateQueryParams = API.DeploymentPaginateQueryParams;
  export import DeploymentPauseDeploymentParams = API.DeploymentPauseDeploymentParams;
  export import DeploymentResumeDeploymentParams = API.DeploymentResumeDeploymentParams;

  export import Events = API.Events;
  export import EventCount = API.EventCount;
  export import EventPage = API.EventPage;
  export import EventCreateParams = API.EventCreateParams;

  export import FlowRunNotificationPolicies = API.FlowRunNotificationPolicies;
  export import FlowRunNotificationPolicy = API.FlowRunNotificationPolicy;
  export import FlowRunNotificationPolicyCreateParams = API.FlowRunNotificationPolicyCreateParams;
  export import FlowRunNotificationPolicyRetrieveParams = API.FlowRunNotificationPolicyRetrieveParams;
  export import FlowRunNotificationPolicyUpdateParams = API.FlowRunNotificationPolicyUpdateParams;
  export import FlowRunNotificationPolicyDeleteParams = API.FlowRunNotificationPolicyDeleteParams;

  export import FlowRunStates = API.FlowRunStates;
  export import FlowRunStateListResponse = API.FlowRunStateListResponse;
  export import FlowRunStateRetrieveParams = API.FlowRunStateRetrieveParams;
  export import FlowRunStateListParams = API.FlowRunStateListParams;

  export import FlowRuns = API.FlowRuns;
  export import DependencyResult = API.DependencyResult;
  export import FlowRunInput = API.FlowRunInput;
  export import FlowRunPaginationResponse = API.FlowRunPaginationResponse;
  export import Graph = API.Graph;
  export import FlowRunCountResponse = API.FlowRunCountResponse;
  export import FlowRunFilterResponse = API.FlowRunFilterResponse;
  export import FlowRunHistoryResponse = API.FlowRunHistoryResponse;
  export import FlowRunLatenessResponse = API.FlowRunLatenessResponse;
  export import FlowRunCreateParams = API.FlowRunCreateParams;
  export import FlowRunRetrieveParams = API.FlowRunRetrieveParams;
  export import FlowRunUpdateParams = API.FlowRunUpdateParams;
  export import FlowRunDeleteParams = API.FlowRunDeleteParams;
  export import FlowRunCountParams = API.FlowRunCountParams;
  export import FlowRunFilterParams = API.FlowRunFilterParams;
  export import FlowRunHistoryParams = API.FlowRunHistoryParams;
  export import FlowRunLatenessParams = API.FlowRunLatenessParams;
  export import FlowRunPaginateParams = API.FlowRunPaginateParams;
  export import FlowRunResumeParams = API.FlowRunResumeParams;
  export import FlowRunSetStateParams = API.FlowRunSetStateParams;

  export import Flows = API.Flows;
  export import Flow = API.Flow;
  export import FlowPaginationResponse = API.FlowPaginationResponse;
  export import FlowCountResponse = API.FlowCountResponse;
  export import FlowFilterResponse = API.FlowFilterResponse;
  export import FlowCreateParams = API.FlowCreateParams;
  export import FlowRetrieveParams = API.FlowRetrieveParams;
  export import FlowUpdateParams = API.FlowUpdateParams;
  export import FlowDeleteParams = API.FlowDeleteParams;
  export import FlowCountParams = API.FlowCountParams;
  export import FlowFilterParams = API.FlowFilterParams;
  export import FlowPaginateParams = API.FlowPaginateParams;
  export import FlowRetrieveByNameParams = API.FlowRetrieveByNameParams;

  export import Root = API.Root;
  export import RootHelloResponse = API.RootHelloResponse;
  export import RootRetrieveHealthResponse = API.RootRetrieveHealthResponse;
  export import RootRetrieveReadyResponse = API.RootRetrieveReadyResponse;
  export import RootVersionResponse = API.RootVersionResponse;
  export import RootHelloParams = API.RootHelloParams;
  export import RootRetrieveReadyParams = API.RootRetrieveReadyParams;

  export import Logs = API.Logs;
  export import Log = API.Log;
  export import LogCreateResponse = API.LogCreateResponse;
  export import LogFilterResponse = API.LogFilterResponse;
  export import LogCreateParams = API.LogCreateParams;
  export import LogFilterParams = API.LogFilterParams;

  export import SavedSearches = API.SavedSearches;
  export import SavedSearch = API.SavedSearch;
  export import SavedSearchFilterResponse = API.SavedSearchFilterResponse;
  export import SavedSearchRetrieveParams = API.SavedSearchRetrieveParams;
  export import SavedSearchUpdateParams = API.SavedSearchUpdateParams;
  export import SavedSearchDeleteParams = API.SavedSearchDeleteParams;
  export import SavedSearchFilterParams = API.SavedSearchFilterParams;

  export import TaskRunStates = API.TaskRunStates;
  export import TaskRunStateListResponse = API.TaskRunStateListResponse;
  export import TaskRunStateRetrieveParams = API.TaskRunStateRetrieveParams;
  export import TaskRunStateListParams = API.TaskRunStateListParams;

  export import TaskRuns = API.TaskRuns;
  export import TaskRun = API.TaskRun;
  export import TaskRunCountResponse = API.TaskRunCountResponse;
  export import TaskRunHistoryResponse = API.TaskRunHistoryResponse;
  export import TaskRunQueryResponse = API.TaskRunQueryResponse;
  export import TaskRunCreateParams = API.TaskRunCreateParams;
  export import TaskRunRetrieveParams = API.TaskRunRetrieveParams;
  export import TaskRunUpdateParams = API.TaskRunUpdateParams;
  export import TaskRunDeleteParams = API.TaskRunDeleteParams;
  export import TaskRunCountParams = API.TaskRunCountParams;
  export import TaskRunHistoryParams = API.TaskRunHistoryParams;
  export import TaskRunQueryParams = API.TaskRunQueryParams;
  export import TaskRunSetStateParams = API.TaskRunSetStateParams;

  export import TaskWorkers = API.TaskWorkers;
  export import TaskWorkerResponse = API.TaskWorkerResponse;
  export import TaskWorkerQueryResponse = API.TaskWorkerQueryResponse;
  export import TaskWorkerQueryParams = API.TaskWorkerQueryParams;

  export import Ui = API.Ui;

  export import ConcurrencyLimitsV2 = API.ConcurrencyLimitsV2;
  export import ConcurrencyLimitV2 = API.ConcurrencyLimitV2;
  export import GlobalConcurrencyLimitResponse = API.GlobalConcurrencyLimitResponse;
  export import ConcurrencyLimitsV2DecrementResponse = API.ConcurrencyLimitsV2DecrementResponse;
  export import ConcurrencyLimitsV2FilterResponse = API.ConcurrencyLimitsV2FilterResponse;
  export import ConcurrencyLimitsV2IncrementResponse = API.ConcurrencyLimitsV2IncrementResponse;
  export import ConcurrencyLimitsV2CreateParams = API.ConcurrencyLimitsV2CreateParams;
  export import ConcurrencyLimitsV2RetrieveParams = API.ConcurrencyLimitsV2RetrieveParams;
  export import ConcurrencyLimitsV2UpdateParams = API.ConcurrencyLimitsV2UpdateParams;
  export import ConcurrencyLimitsV2DeleteParams = API.ConcurrencyLimitsV2DeleteParams;
  export import ConcurrencyLimitsV2DecrementParams = API.ConcurrencyLimitsV2DecrementParams;
  export import ConcurrencyLimitsV2FilterParams = API.ConcurrencyLimitsV2FilterParams;
  export import ConcurrencyLimitsV2IncrementParams = API.ConcurrencyLimitsV2IncrementParams;

  export import Variables = API.Variables;
  export import VariableCountResponse = API.VariableCountResponse;
  export import VariableFilterResponse = API.VariableFilterResponse;
  export import VariableCreateParams = API.VariableCreateParams;
  export import VariableRetrieveParams = API.VariableRetrieveParams;
  export import VariableUpdateParams = API.VariableUpdateParams;
  export import VariableDeleteParams = API.VariableDeleteParams;
  export import VariableCountParams = API.VariableCountParams;
  export import VariableFilterParams = API.VariableFilterParams;
  export import VariableUpdateNameParams = API.VariableUpdateNameParams;

  export import WorkPools = API.WorkPools;
  export import WorkPool = API.WorkPool;
  export import WorkerFlowRunResponse = API.WorkerFlowRunResponse;
  export import WorkPoolCountResponse = API.WorkPoolCountResponse;
  export import WorkPoolGetScheduledFlowRunsResponse = API.WorkPoolGetScheduledFlowRunsResponse;
  export import WorkPoolListFilteredResponse = API.WorkPoolListFilteredResponse;
  export import WorkPoolCreateParams = API.WorkPoolCreateParams;
  export import WorkPoolRetrieveParams = API.WorkPoolRetrieveParams;
  export import WorkPoolUpdateParams = API.WorkPoolUpdateParams;
  export import WorkPoolDeleteParams = API.WorkPoolDeleteParams;
  export import WorkPoolCountParams = API.WorkPoolCountParams;
  export import WorkPoolGetScheduledFlowRunsParams = API.WorkPoolGetScheduledFlowRunsParams;
  export import WorkPoolListFilteredParams = API.WorkPoolListFilteredParams;

  export import WorkQueues = API.WorkQueues;
  export import WorkQueueStatusDetail = API.WorkQueueStatusDetail;
  export import WorkQueueFilterResponse = API.WorkQueueFilterResponse;
  export import WorkQueueGetRunsResponse = API.WorkQueueGetRunsResponse;
  export import WorkQueueCreateParams = API.WorkQueueCreateParams;
  export import WorkQueueRetrieveParams = API.WorkQueueRetrieveParams;
  export import WorkQueueUpdateParams = API.WorkQueueUpdateParams;
  export import WorkQueueDeleteParams = API.WorkQueueDeleteParams;
  export import WorkQueueFilterParams = API.WorkQueueFilterParams;
  export import WorkQueueGetRunsParams = API.WorkQueueGetRunsParams;
  export import WorkQueueRetrieveByNameParams = API.WorkQueueRetrieveByNameParams;
  export import WorkQueueStatusParams = API.WorkQueueStatusParams;

  export import BlockDocument = API.BlockDocument;
  export import ConcurrencyLimit = API.ConcurrencyLimit;
  export import FlowRunResponse = API.FlowRunResponse;
  export import HistoryResponse = API.HistoryResponse;
  export import MinimalConcurrencyLimitResponse = API.MinimalConcurrencyLimitResponse;
  export import OrchestrationResult = API.OrchestrationResult;
  export import State = API.State;
  export import Variable = API.Variable;
  export import WorkQueueResponse = API.WorkQueueResponse;
}

export default EndexPrefectDev;