@metabase/client 0.0.0-stage → 0.1.1

package/dist/git-sync-BTf1aYHr.d.ts

@@ -0,0 +1,205 @@
+import { f as RequestOptions, h as Transport } from "./transport-BsXqRujn.js";
+import { t as ListResult } from "./list-BT_bBm9Z.js";
+import { a as PollOptions } from "./poll-CIwnee7h.js";
+import { z } from "zod";
+//#region src/resources/git-sync.d.ts
+declare const SyncScopeCollection: z.ZodObject<{
+  id: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+  name: z.ZodString;
+  is_remote_synced: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strip>;
+type SyncScopeCollection = z.infer<typeof SyncScopeCollection>;
+interface SyncWaitParams {
+  wait?: PollOptions | undefined;
+}
+interface SyncRemoteChangesParams {
+  "force-refresh"?: boolean | undefined;
+}
+interface SyncImportParams extends SyncWaitParams {
+  branch?: string | undefined;
+  force?: boolean | undefined;
+  merge?: boolean | undefined;
+  expected_branch?: string | undefined;
+}
+interface SyncExportParams extends SyncWaitParams {
+  branch?: string | undefined;
+  message?: string | undefined;
+  force?: boolean | undefined;
+  merge?: boolean | undefined;
+}
+interface SyncExportPreflightParams {
+  branch: string;
+}
+interface SyncStashParams extends SyncWaitParams {
+  new_branch: string;
+  message: string;
+}
+interface SyncCreateBranchParams {
+  name: string;
+}
+declare function gitSyncResource(transport: Transport): {
+  currentTask: (options?: RequestOptions | undefined) => Promise<{
+    [x: string]: unknown;
+    id: number;
+    sync_task_type: "import" | "export";
+    status: "running" | "successful" | "errored" | "cancelled" | "timed-out" | "conflict";
+    progress: number | null;
+    started_at: string;
+    ended_at?: string | null | undefined;
+    last_progress_report_at?: string | null | undefined;
+    version?: string | null | undefined;
+    initiated_by?: number | null | undefined;
+    cancelled?: boolean | null | undefined;
+    error_message?: string | null | undefined;
+    conflicts?: string[] | null | undefined;
+  } | null>;
+  cancelTask: (options?: RequestOptions | undefined) => Promise<{
+    [x: string]: unknown;
+    id: number;
+    sync_task_type: "import" | "export";
+    status: "running" | "successful" | "errored" | "cancelled" | "timed-out" | "conflict";
+    progress: number | null;
+    started_at: string;
+    ended_at?: string | null | undefined;
+    last_progress_report_at?: string | null | undefined;
+    version?: string | null | undefined;
+    initiated_by?: number | null | undefined;
+    cancelled?: boolean | null | undefined;
+    error_message?: string | null | undefined;
+    conflicts?: string[] | null | undefined;
+  }>;
+  isDirty: (options?: RequestOptions | undefined) => Promise<boolean>;
+  dirty: (options?: RequestOptions | undefined) => Promise<ListResult<{
+    [x: string]: unknown;
+    id: number;
+    name: string | null;
+    model: string;
+    sync_status: string;
+    collection_id?: number | null | undefined;
+    description?: string | null | undefined;
+    display?: string | null | undefined;
+    query_type?: string | null | undefined;
+    table_id?: number | null | undefined;
+    table_name?: string | null | undefined;
+  }>>;
+  hasRemoteChanges: (params?: SyncRemoteChangesParams | undefined, options?: RequestOptions | undefined) => Promise<{
+    has_changes: boolean;
+    remote_version: string | null;
+    local_version: string | null;
+    cached: boolean;
+  }>;
+  import: (params?: SyncImportParams | undefined, options?: RequestOptions | undefined) => Promise<{
+    message: string | null;
+    task_id: number | null;
+    final?: {
+      [x: string]: unknown;
+      id: number;
+      sync_task_type: "import" | "export";
+      status: "running" | "successful" | "errored" | "cancelled" | "timed-out" | "conflict";
+      progress: number | null;
+      started_at: string;
+      ended_at?: string | null | undefined;
+      last_progress_report_at?: string | null | undefined;
+      version?: string | null | undefined;
+      initiated_by?: number | null | undefined;
+      cancelled?: boolean | null | undefined;
+      error_message?: string | null | undefined;
+      conflicts?: string[] | null | undefined;
+    } | null | undefined;
+  }>;
+  export: (params?: SyncExportParams | undefined, options?: RequestOptions | undefined) => Promise<{
+    message: string;
+    task_id: number;
+    branch: string | null;
+    final?: {
+      [x: string]: unknown;
+      id: number;
+      sync_task_type: "import" | "export";
+      status: "running" | "successful" | "errored" | "cancelled" | "timed-out" | "conflict";
+      progress: number | null;
+      started_at: string;
+      ended_at?: string | null | undefined;
+      last_progress_report_at?: string | null | undefined;
+      version?: string | null | undefined;
+      initiated_by?: number | null | undefined;
+      cancelled?: boolean | null | undefined;
+      error_message?: string | null | undefined;
+      conflicts?: string[] | null | undefined;
+    } | null | undefined;
+  }>;
+  exportPreflight: (params: SyncExportPreflightParams, options?: RequestOptions | undefined) => Promise<{
+    [x: string]: unknown;
+    has_changes: boolean;
+    clean: boolean;
+    conflicts: string[];
+    summary: {
+      added: number;
+      updated: number;
+      removed: number;
+    };
+    force_push_casualties: {
+      deleted: string[];
+      overwritten: string[];
+    };
+    reason: "history-rewritten" | null;
+  }>;
+  stash: (params: SyncStashParams, options?: RequestOptions | undefined) => Promise<{
+    status: "success";
+    message: string;
+    task_id: number;
+    final?: {
+      [x: string]: unknown;
+      id: number;
+      sync_task_type: "import" | "export";
+      status: "running" | "successful" | "errored" | "cancelled" | "timed-out" | "conflict";
+      progress: number | null;
+      started_at: string;
+      ended_at?: string | null | undefined;
+      last_progress_report_at?: string | null | undefined;
+      version?: string | null | undefined;
+      initiated_by?: number | null | undefined;
+      cancelled?: boolean | null | undefined;
+      error_message?: string | null | undefined;
+      conflicts?: string[] | null | undefined;
+    } | null | undefined;
+  }>;
+  branches: (options?: RequestOptions | undefined) => Promise<ListResult<string>>;
+  createBranch: (params: SyncCreateBranchParams, options?: RequestOptions | undefined) => Promise<{
+    status: "success";
+    message: string;
+  }>;
+  setCollectionSynced: (collectionId: number, synced: boolean, options?: RequestOptions | undefined) => Promise<{
+    success: boolean;
+    task_id?: number | undefined;
+  }>;
+  syncedCollections: (options?: RequestOptions | undefined) => Promise<ListResult<{
+    id: string | number;
+    name: string;
+    is_remote_synced?: boolean | null | undefined;
+  }>>;
+  remoteUrl: (options?: RequestOptions) => Promise<string | null>;
+  branch: (options?: RequestOptions) => Promise<string | null>;
+  remote: (options?: RequestOptions) => Promise<{
+    configured: boolean;
+    sync_type: string;
+    branch: string | null;
+  }>;
+  trackedBranch: (options?: RequestOptions) => Promise<string>;
+  waitForTask: (wait: PollOptions, options?: RequestOptions | undefined) => Promise<{
+    [x: string]: unknown;
+    id: number;
+    sync_task_type: "import" | "export";
+    status: "running" | "successful" | "errored" | "cancelled" | "timed-out" | "conflict";
+    progress: number | null;
+    started_at: string;
+    ended_at?: string | null | undefined;
+    last_progress_report_at?: string | null | undefined;
+    version?: string | null | undefined;
+    initiated_by?: number | null | undefined;
+    cancelled?: boolean | null | undefined;
+    error_message?: string | null | undefined;
+    conflicts?: string[] | null | undefined;
+  } | null>;
+};
+//#endregion
+export { SyncRemoteChangesParams as a, SyncWaitParams as c, SyncImportParams as i, gitSyncResource as l, SyncExportParams as n, SyncScopeCollection as o, SyncExportPreflightParams as r, SyncStashParams as s, SyncCreateBranchParams as t };

package/dist/git-sync-C99SVdJ9.d.ts

@@ -0,0 +1,258 @@
+import { z } from "zod";
+//#region src/domain/git-sync.d.ts
+declare const SyncTaskStatus: z.ZodEnum<{
+  running: "running";
+  successful: "successful";
+  errored: "errored";
+  cancelled: "cancelled";
+  "timed-out": "timed-out";
+  conflict: "conflict";
+}>;
+type SyncTaskStatus = z.infer<typeof SyncTaskStatus>;
+declare const SyncTaskType: z.ZodEnum<{
+  import: "import";
+  export: "export";
+}>;
+type SyncTaskType = z.infer<typeof SyncTaskType>;
+/**
+ * The direction an instance syncs in: `read-only` follows the remote branch and refuses local edits
+ * to synced content; `read-write` also exports its own changes.
+ */
+declare const SyncType: z.ZodEnum<{
+  "read-only": "read-only";
+  "read-write": "read-write";
+}>;
+type SyncType = z.infer<typeof SyncType>;
+/**
+ * Whether a remote is configured, the direction the instance syncs in, and the branch it tracks,
+ * `null` when none is set. The sync type is a `SyncType` when an admin sets it; a server that reads
+ * `MB_REMOTE_SYNC_TYPE` (60 and later) does not check that value, so it is the string the server
+ * holds.
+ */
+declare const RemoteSyncState: z.ZodObject<{
+  configured: z.ZodBoolean;
+  sync_type: z.ZodString;
+  branch: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type RemoteSyncState = z.infer<typeof RemoteSyncState>;
+/** Whether the server will report any further progress for a task in this status. */
+declare function isSyncTaskTerminal(status: SyncTaskStatus): boolean;
+/** Whether a terminal status means the sync did not carry out what it was asked to. */
+declare function isSyncTaskFailed(status: SyncTaskStatus): boolean;
+declare const SyncTask: z.ZodObject<{
+  id: z.ZodNumber;
+  sync_task_type: z.ZodEnum<{
+    import: "import";
+    export: "export";
+  }>;
+  status: z.ZodEnum<{
+    running: "running";
+    successful: "successful";
+    errored: "errored";
+    cancelled: "cancelled";
+    "timed-out": "timed-out";
+    conflict: "conflict";
+  }>;
+  progress: z.ZodNullable<z.ZodNumber>;
+  started_at: z.ZodString;
+  ended_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  last_progress_report_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  initiated_by: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  cancelled: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+  error_message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  conflicts: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+}, z.core.$loose>;
+type SyncTask = z.infer<typeof SyncTask>;
+declare const SyncTaskCompact: z.ZodObject<{
+  id: z.ZodNumber;
+  version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  sync_task_type: z.ZodEnum<{
+    import: "import";
+    export: "export";
+  }>;
+  status: z.ZodEnum<{
+    running: "running";
+    successful: "successful";
+    errored: "errored";
+    cancelled: "cancelled";
+    "timed-out": "timed-out";
+    conflict: "conflict";
+  }>;
+  progress: z.ZodNullable<z.ZodNumber>;
+  error_message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  conflicts: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+type SyncTaskCompact = z.infer<typeof SyncTaskCompact>;
+declare const SyncDirtyItem: z.ZodObject<{
+  id: z.ZodNumber;
+  name: z.ZodNullable<z.ZodString>;
+  model: z.ZodString;
+  sync_status: z.ZodString;
+  collection_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  display: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  query_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  table_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  table_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+type SyncDirtyItem = z.infer<typeof SyncDirtyItem>;
+declare const SyncDirtyItemCompact: z.ZodObject<{
+  id: z.ZodNumber;
+  name: z.ZodNullable<z.ZodString>;
+  collection_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  model: z.ZodString;
+  sync_status: z.ZodString;
+}, z.core.$strip>;
+type SyncDirtyItemCompact = z.infer<typeof SyncDirtyItemCompact>;
+declare const SyncRemoteChanges: z.ZodObject<{
+  has_changes: z.ZodBoolean;
+  remote_version: z.ZodNullable<z.ZodString>;
+  local_version: z.ZodNullable<z.ZodString>;
+  cached: z.ZodBoolean;
+}, z.core.$strip>;
+type SyncRemoteChanges = z.infer<typeof SyncRemoteChanges>;
+declare const SyncMergeSummary: z.ZodObject<{
+  added: z.ZodNumber;
+  updated: z.ZodNumber;
+  removed: z.ZodNumber;
+}, z.core.$strip>;
+type SyncMergeSummary = z.infer<typeof SyncMergeSummary>;
+declare const SyncForcePushCasualties: z.ZodObject<{
+  deleted: z.ZodArray<z.ZodString>;
+  overwritten: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type SyncForcePushCasualties = z.infer<typeof SyncForcePushCasualties>;
+declare const SyncExportPreflight: z.ZodObject<{
+  has_changes: z.ZodBoolean;
+  clean: z.ZodBoolean;
+  conflicts: z.ZodArray<z.ZodString>;
+  summary: z.ZodObject<{
+    added: z.ZodNumber;
+    updated: z.ZodNumber;
+    removed: z.ZodNumber;
+  }, z.core.$strip>;
+  force_push_casualties: z.ZodObject<{
+    deleted: z.ZodArray<z.ZodString>;
+    overwritten: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>;
+  reason: z.ZodNullable<z.ZodLiteral<"history-rewritten">>;
+}, z.core.$loose>;
+type SyncExportPreflight = z.infer<typeof SyncExportPreflight>;
+declare const SyncExportPreflightCompact: z.ZodObject<{
+  summary: z.ZodObject<{
+    added: z.ZodNumber;
+    updated: z.ZodNumber;
+    removed: z.ZodNumber;
+  }, z.core.$strip>;
+  conflicts: z.ZodArray<z.ZodString>;
+  has_changes: z.ZodBoolean;
+  force_push_casualties: z.ZodObject<{
+    deleted: z.ZodArray<z.ZodString>;
+    overwritten: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>;
+  clean: z.ZodBoolean;
+  reason: z.ZodNullable<z.ZodLiteral<"history-rewritten">>;
+}, z.core.$strip>;
+type SyncExportPreflightCompact = z.infer<typeof SyncExportPreflightCompact>;
+declare const SyncBranchCreated: z.ZodObject<{
+  status: z.ZodLiteral<"success">;
+  message: z.ZodString;
+}, z.core.$strip>;
+type SyncBranchCreated = z.infer<typeof SyncBranchCreated>;
+declare const SyncSettingsUpdateResult: z.ZodObject<{
+  success: z.ZodBoolean;
+  task_id: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type SyncSettingsUpdateResult = z.infer<typeof SyncSettingsUpdateResult>;
+declare const SyncImportResult: z.ZodObject<{
+  message: z.ZodNullable<z.ZodString>;
+  task_id: z.ZodNullable<z.ZodNumber>;
+  final: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+    id: z.ZodNumber;
+    sync_task_type: z.ZodEnum<{
+      import: "import";
+      export: "export";
+    }>;
+    status: z.ZodEnum<{
+      running: "running";
+      successful: "successful";
+      errored: "errored";
+      cancelled: "cancelled";
+      "timed-out": "timed-out";
+      conflict: "conflict";
+    }>;
+    progress: z.ZodNullable<z.ZodNumber>;
+    started_at: z.ZodString;
+    ended_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    last_progress_report_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    initiated_by: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    cancelled: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    error_message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    conflicts: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+  }, z.core.$loose>>>;
+}, z.core.$strip>;
+type SyncImportResult = z.infer<typeof SyncImportResult>;
+declare const SyncExportResult: z.ZodObject<{
+  message: z.ZodString;
+  task_id: z.ZodNumber;
+  branch: z.ZodNullable<z.ZodString>;
+  final: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+    id: z.ZodNumber;
+    sync_task_type: z.ZodEnum<{
+      import: "import";
+      export: "export";
+    }>;
+    status: z.ZodEnum<{
+      running: "running";
+      successful: "successful";
+      errored: "errored";
+      cancelled: "cancelled";
+      "timed-out": "timed-out";
+      conflict: "conflict";
+    }>;
+    progress: z.ZodNullable<z.ZodNumber>;
+    started_at: z.ZodString;
+    ended_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    last_progress_report_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    initiated_by: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    cancelled: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    error_message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    conflicts: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+  }, z.core.$loose>>>;
+}, z.core.$strip>;
+type SyncExportResult = z.infer<typeof SyncExportResult>;
+declare const SyncStashResult: z.ZodObject<{
+  status: z.ZodLiteral<"success">;
+  message: z.ZodString;
+  task_id: z.ZodNumber;
+  final: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+    id: z.ZodNumber;
+    sync_task_type: z.ZodEnum<{
+      import: "import";
+      export: "export";
+    }>;
+    status: z.ZodEnum<{
+      running: "running";
+      successful: "successful";
+      errored: "errored";
+      cancelled: "cancelled";
+      "timed-out": "timed-out";
+      conflict: "conflict";
+    }>;
+    progress: z.ZodNullable<z.ZodNumber>;
+    started_at: z.ZodString;
+    ended_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    last_progress_report_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    initiated_by: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    cancelled: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    error_message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    conflicts: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+  }, z.core.$loose>>>;
+}, z.core.$strip>;
+type SyncStashResult = z.infer<typeof SyncStashResult>;
+//#endregion
+export { SyncTaskType as _, SyncExportPreflight as a, isSyncTaskTerminal as b, SyncForcePushCasualties as c, SyncRemoteChanges as d, SyncSettingsUpdateResult as f, SyncTaskStatus as g, SyncTaskCompact as h, SyncDirtyItemCompact as i, SyncImportResult as l, SyncTask as m, SyncBranchCreated as n, SyncExportPreflightCompact as o, SyncStashResult as p, SyncDirtyItem as r, SyncExportResult as s, RemoteSyncState as t, SyncMergeSummary as u, SyncType as v, isSyncTaskFailed as y };

package/dist/glossary-CHK3elPj.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+//#region src/domain/glossary.d.ts
+declare const Glossary: z.ZodObject<{
+  id: z.ZodNumber;
+  term: z.ZodString;
+  definition: z.ZodString;
+  creator_id: z.ZodNumber;
+  creator: z.ZodObject<{
+    id: z.ZodNumber;
+    email: z.ZodString;
+    first_name: z.ZodNullable<z.ZodString>;
+    last_name: z.ZodNullable<z.ZodString>;
+  }, z.core.$loose>;
+  created_at: z.ZodString;
+  updated_at: z.ZodString;
+}, z.core.$loose>;
+type Glossary = z.infer<typeof Glossary>;
+declare const GlossaryCompact: z.ZodObject<{
+  id: z.ZodNumber;
+  definition: z.ZodString;
+  term: z.ZodString;
+}, z.core.$strip>;
+type GlossaryCompact = z.infer<typeof GlossaryCompact>;
+declare const GlossaryCreateInput: z.ZodObject<{
+  term: z.ZodString;
+  definition: z.ZodString;
+}, z.core.$strict>;
+type GlossaryCreateInput = z.infer<typeof GlossaryCreateInput>;
+declare const GlossaryUpdateInput: z.ZodObject<{
+  term: z.ZodString;
+  definition: z.ZodString;
+}, z.core.$strict>;
+type GlossaryUpdateInput = GlossaryCreateInput;
+//#endregion
+export { GlossaryUpdateInput as i, GlossaryCompact as n, GlossaryCreateInput as r, Glossary as t };

package/dist/glossary-DFvnz-E5.d.ts

@@ -0,0 +1,15 @@
+import { f as RequestOptions, h as Transport } from "./transport-BsXqRujn.js";
+import { t as ListResult } from "./list-BT_bBm9Z.js";
+import { i as GlossaryUpdateInput, r as GlossaryCreateInput, t as Glossary } from "./glossary-CHK3elPj.js";
+//#region src/resources/glossary.d.ts
+interface GlossaryListParams {
+  search?: string | undefined;
+}
+declare function glossaryResource(transport: Transport): {
+  list: (params?: GlossaryListParams, options?: RequestOptions) => Promise<ListResult<Glossary>>;
+  create: (params: GlossaryCreateInput, options?: RequestOptions) => Promise<Glossary>;
+  update: (id: number, params: GlossaryUpdateInput, options?: RequestOptions) => Promise<Glossary>;
+  delete: (id: number, options?: RequestOptions) => Promise<void>;
+};
+//#endregion
+export { glossaryResource as n, GlossaryListParams as t };

package/dist/http/errors.d.ts

@@ -0,0 +1,2 @@
+import { A as HttpErrorDetail, B as isHttpNotFound, D as FORBIDDEN_STATUS, E as FIELD_PATH_SEPARATOR, F as PAYMENT_REQUIRED_STATUS, I as RemoteSyncedDependent, L as TOO_MANY_REQUESTS_STATUS, M as HttpErrorKind, N as INTERNAL_SERVER_ERROR_STATUS, O as FieldErrors, P as NOT_FOUND_STATUS, R as UNAUTHORIZED_STATUS, T as CONFLICT_STATUS, V as isRetryableStatus, j as HttpErrorInput, k as HttpError, w as BAD_REQUEST_STATUS, z as chainRequestFailure } from "../transport-BsXqRujn.js";
+export { BAD_REQUEST_STATUS, CONFLICT_STATUS, FIELD_PATH_SEPARATOR, FORBIDDEN_STATUS, FieldErrors, HttpError, HttpErrorDetail, HttpErrorInput, HttpErrorKind, INTERNAL_SERVER_ERROR_STATUS, NOT_FOUND_STATUS, PAYMENT_REQUIRED_STATUS, RemoteSyncedDependent, TOO_MANY_REQUESTS_STATUS, UNAUTHORIZED_STATUS, chainRequestFailure, isHttpNotFound, isRetryableStatus };

package/dist/http/errors.js

@@ -0,0 +1,2 @@
+import { a as HttpError, c as PAYMENT_REQUIRED_STATUS, d as chainRequestFailure, f as isHttpNotFound, i as FORBIDDEN_STATUS, l as TOO_MANY_REQUESTS_STATUS, n as CONFLICT_STATUS, o as INTERNAL_SERVER_ERROR_STATUS, p as isRetryableStatus, r as FIELD_PATH_SEPARATOR, s as NOT_FOUND_STATUS, t as BAD_REQUEST_STATUS, u as UNAUTHORIZED_STATUS } from "../errors-DdMlaXqq.js";
+export { BAD_REQUEST_STATUS, CONFLICT_STATUS, FIELD_PATH_SEPARATOR, FORBIDDEN_STATUS, HttpError, INTERNAL_SERVER_ERROR_STATUS, NOT_FOUND_STATUS, PAYMENT_REQUIRED_STATUS, TOO_MANY_REQUESTS_STATUS, UNAUTHORIZED_STATUS, chainRequestFailure, isHttpNotFound, isRetryableStatus };

package/dist/http/oauth.d.ts

@@ -0,0 +1,2 @@
+import { a as OAuthServerMetadata, c as TokenRefresh, d as discoverMetadata, f as exchangeCode, g as tryDiscoverMetadata, h as revokeToken, i as OAUTH_UNSUPPORTED_MESSAGE, l as TokenRevocation, m as registerClient, n as CodeExchange, o as OAuthTokens, p as refreshTokens, r as OAUTH_SCOPE, s as RegisteredClient, t as ClientRegistration, u as discoverLoginMetadata } from "../oauth-C4ordeoJ.js";
+export { ClientRegistration, CodeExchange, OAUTH_SCOPE, OAUTH_UNSUPPORTED_MESSAGE, OAuthServerMetadata, OAuthTokens, RegisteredClient, TokenRefresh, TokenRevocation, discoverLoginMetadata, discoverMetadata, exchangeCode, refreshTokens, registerClient, revokeToken, tryDiscoverMetadata };