@corsair-dev/higgsfield 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,191 @@
+  Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work 
+      (which shall not include Communications that are clearly marked or
+      otherwise designated in writing by the copyright owner as "Not a Work").
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution".
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright (c) 2026 Corsair
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,41 @@
-# Temporary Holding Version
+# @corsair-dev/higgsfield
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Higgsfield plugin for Corsair.
+
+## Install
+
+```bash
+pnpm add @corsair-dev/higgsfield
+```
+
+## Endpoints
+
+| Operation | Operation ID | Risk | Description |
+|-----------|--------------|------|-------------|
+| `files.createUploadUrl` | `higgsfield.api.files.createUploadUrl` | `write` | Get a presigned URL to PUT an input file to yourself, and the public URL it will have. For most uses files.upload does both steps. |
+| `files.upload` | `higgsfield.api.files.upload` | `write` | Upload an image, audio or video file from base64 and get the public URL to pass as a model input. A file already at a public https URL needs no upload: pass that URL to the model. |
+| `generations.estimate` | `higgsfield.api.generations.estimate` | `read` | What a generation with these inputs would cost, in US dollars and credits. Free; nothing runs. |
+| `generations.run` | `higgsfield.api.generations.run` | `write` | Generate and wait up to waitSeconds (default 10, at most 15) for the output; spends account balance when it completes. Answers like requests.status: queued or in_progress is a job to follow with requests.status, and video usually takes longer than the wait. Outputs expire after 7 days by default. |
+| `generations.submit` | `higgsfield.api.generations.submit` | `write` | Queue a generation (image, video…) and get a request id back at once; spends account balance when it completes. Follow it with requests.status until it is completed, failed, nsfw or canceled, or pass webhookUrl. Outputs expire after 7 days by default. Repeating with the returned idempotency_key is never charged twice. |
+| `models.get` | `higgsfield.api.models.get` | `read` | One model by its path, with its input fields (input_schema). Read this before a generation: every model takes its own fields. |
+| `models.list` | `higgsfield.api.models.list` | `read` | Find Higgsfield models by text, output type or operation; includeSchema adds their input fields |
+| `requests.cancel` | `higgsfield.api.requests.cancel` | `write` | Cancel a request that is still queued and refund it. Once it has started it cannot be canceled, and this errors. |
+| `requests.delete` | `higgsfield.api.requests.delete` | `destructive` | Delete a finished request's files, prompt and parameters now. Billing records stay. A request still running gets a 409. |
+| `requests.status` | `higgsfield.api.requests.status` | `read` | Where a request stands, with its output URLs once completed. Output URLs stop working at expires_at, 7 days after it finished by default. |
+| `usage.get` | `higgsfield.api.usage.get` | `read` | Completed generations and their estimated cost by model and time bucket. For monitoring: it can lag and is not a billing record. |
+
+## Auth
+
+Auth: API key. Corsair prompts your tenant for credentials on first use.
+
+## Webhooks
+
+Handles 1 webhook event. See the reference for payloads and `webhookHooks`.
+
+## Reference
+
+Full docs, types, and examples: https://docs.corsair.dev/plugins/higgsfield
+
+## License
+
+Apache-2.0

package/dist/api.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=api.test.d.ts.map

package/dist/api.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.test.d.ts","sourceRoot":"","sources":["../api.test.ts"],"names":[],"mappings":""}

package/dist/client.d.ts

@@ -0,0 +1,82 @@
+import { ApiError } from 'corsair/http';
+/** The one host the API key is ever sent to. */
+export declare const HIGGSFIELD_API_BASE = "https://api.higgsfield.ai";
+export type HiggsfieldErrorCode = 'invalid_key' | 'invalid_input' | 'network' | 'timeout' | 'bad_response' | 'not_found' | 'upload_failed';
+/** A failure that isn't an HTTP answer from the API: bad input, the network, the upload. */
+export declare class HiggsfieldError extends Error {
+    readonly code: HiggsfieldErrorCode;
+    /** Set on a failed submit: repeat with this key and no second charge is made. */
+    idempotencyKey?: string;
+    constructor(message: string, code: HiggsfieldErrorCode);
+}
+/** An HTTP error answer from the API, with the detail text and correlation id kept. */
+export declare class HiggsfieldAPIError extends ApiError {
+    readonly correlationId?: string;
+    /** The `detail.code` of a structured error, for example account_queue_full. */
+    readonly detailCode?: string;
+    /** The `detail.retryable` of a structured error. */
+    readonly retryable?: boolean;
+    /** Set on a failed submit: repeat with this key and no second charge is made. */
+    idempotencyKey?: string;
+    constructor(init: {
+        method: 'GET' | 'POST' | 'DELETE';
+        path: string;
+        status: number;
+        statusText: string;
+        body: unknown;
+        message: string;
+        correlationId?: string;
+        retryAfterMs?: number;
+        detailCode?: string;
+        retryable?: boolean;
+    });
+}
+/**
+ * `Authorization: Key <id>:<secret>`. A key with no colon is refused here, on
+ * the way to every call, and the message never repeats any of it.
+ */
+export declare function authorizationHeader(apiKey: string): string;
+/** Strips one surrounding slash; null when this cannot be a model path. */
+export declare function normalizeModelPath(modelPath: string): string | null;
+/** The path a generation is submitted to. */
+export declare function submitPath(modelPath: string): string;
+/** The path a generation is priced at. */
+export declare function estimatePath(modelPath: string): string;
+export declare function isValidRequestId(requestId: string): boolean;
+/**
+ * Built from the request id, not from the status_url or cancel_url a response
+ * carries: those are the same paths today, and following a URL out of a
+ * response could send the key to another host.
+ */
+export declare function requestPath(requestId: string, action?: 'status' | 'cancel'): string;
+export type HiggsfieldRequestInit = {
+    method?: 'GET' | 'POST' | 'DELETE';
+    query?: Record<string, string | number | boolean | readonly string[] | undefined>;
+    body?: unknown;
+    headers?: Record<string, string | undefined>;
+    timeoutMs?: number;
+};
+type ErrorDetail = {
+    text: string;
+    code?: string;
+    retryable?: boolean;
+    retryAfterSeconds?: number;
+};
+/** Reads the FastAPI `detail`, which is a string, a validation list or an object. */
+export declare function readErrorDetail(body: unknown): ErrorDetail;
+/**
+ * Calls the API. A plain fetch rather than `corsair/http`'s `request`, whose
+ * errors drop the response headers: support needs X-Correlation-ID, and its
+ * fixed status messages would replace Higgsfield's detail text. Redirects are
+ * refused so the key cannot follow one, and the transport makes one attempt:
+ * retries are error-handlers.ts's call.
+ */
+export declare function makeHiggsfieldRequest<T>(apiKey: string, path: string, init?: HiggsfieldRequestInit): Promise<T>;
+/**
+ * PUTs bytes to the presigned URL files/generate-upload-url returned, with
+ * every header it asked for. The URL carries its own signature, so no
+ * Higgsfield credentials go with it, and the URL stays out of errors.
+ */
+export declare function putToPresignedUrl(uploadUrl: string, bytes: Uint8Array, headers: Record<string, string>): Promise<void>;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../client.ts"],"names":[],"mappings":"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"}

package/dist/client.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=client.test.d.ts.map

package/dist/client.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.test.d.ts","sourceRoot":"","sources":["../client.test.ts"],"names":[],"mappings":""}

package/dist/endpoints/files.d.ts

@@ -0,0 +1,4 @@
+import type { HiggsfieldEndpoints } from '../index';
+export declare const createUploadUrl: HiggsfieldEndpoints['filesCreateUploadUrl'];
+export declare const upload: HiggsfieldEndpoints['filesUpload'];
+//# sourceMappingURL=files.d.ts.map

package/dist/endpoints/files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../../endpoints/files.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AA6DpD,eAAO,MAAM,eAAe,EAAE,mBAAmB,CAAC,sBAAsB,CAYtE,CAAC;AAEH,eAAO,MAAM,MAAM,EAAE,mBAAmB,CAAC,aAAa,CA0BrD,CAAC"}

package/dist/endpoints/generations.d.ts

@@ -0,0 +1,11 @@
+import type { HiggsfieldEndpoints } from '../index';
+export declare const submit: HiggsfieldEndpoints['generationsSubmit'];
+/**
+ * Submits and waits a little for the end. Nothing after the submit throws: an
+ * error here would read as a failed call, and a caller or retry handler would
+ * pay for the generation again. A request that hasn't ended, or whose status
+ * couldn't be read, comes back as the job it is.
+ */
+export declare const run: HiggsfieldEndpoints['generationsRun'];
+export declare const estimate: HiggsfieldEndpoints['generationsEstimate'];
+//# sourceMappingURL=generations.d.ts.map

package/dist/endpoints/generations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generations.d.ts","sourceRoot":"","sources":["../../endpoints/generations.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAqB,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAkJvE,eAAO,MAAM,MAAM,EAAE,mBAAmB,CAAC,mBAAmB,CAY3D,CAAC;AAwDF;;;;;GAKG;AACH,eAAO,MAAM,GAAG,EAAE,mBAAmB,CAAC,gBAAgB,CAoCrD,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,mBAAmB,CAAC,qBAAqB,CAmB/D,CAAC"}

package/dist/endpoints/index.d.ts

@@ -0,0 +1,198 @@
+export declare const Generations: {
+    submit: (ctx: import("..").HiggsfieldContext, args: {
+        modelPath: string;
+        input: Record<string, unknown>;
+        webhookUrl?: string | undefined;
+        idempotencyKey?: string | undefined;
+        expiresAfter?: number | undefined;
+    }) => Promise<{
+        [x: string]: unknown;
+        status: string;
+        request_id: string;
+        idempotency_key: string;
+        status_url?: string | null | undefined;
+        cancel_url?: string | null | undefined;
+        expires_after?: number | null | undefined;
+    }>;
+    run: (ctx: import("..").HiggsfieldContext, args: {
+        modelPath: string;
+        input: Record<string, unknown>;
+        webhookUrl?: string | undefined;
+        idempotencyKey?: string | undefined;
+        expiresAfter?: number | undefined;
+        waitSeconds?: number | undefined;
+    }) => Promise<{
+        [x: string]: unknown;
+        status: string;
+        request_id: string;
+        idempotency_key: string;
+        status_url?: string | null | undefined;
+        cancel_url?: string | null | undefined;
+        error?: string | Record<string, unknown> | null | undefined;
+        expires_at?: string | null | undefined;
+        images?: {
+            [x: string]: unknown;
+            url?: string | null | undefined;
+            content_type?: string | null | undefined;
+        }[] | null | undefined;
+        video?: {
+            [x: string]: unknown;
+            url?: string | null | undefined;
+            content_type?: string | null | undefined;
+        } | null | undefined;
+        audio?: {
+            [x: string]: unknown;
+            url?: string | null | undefined;
+            content_type?: string | null | undefined;
+        } | null | undefined;
+        audios?: {
+            [x: string]: unknown;
+            url?: string | null | undefined;
+            content_type?: string | null | undefined;
+        }[] | null | undefined;
+        expires_after?: number | null | undefined;
+    }>;
+    estimate: (ctx: import("..").HiggsfieldContext, args: {
+        modelPath: string;
+        input: Record<string, unknown>;
+    }) => Promise<{
+        [x: string]: unknown;
+        type?: string | null | undefined;
+        credits?: string | null | undefined;
+        usd?: string | null | undefined;
+        discount?: unknown;
+    }>;
+};
+export declare const Requests: {
+    status: (ctx: import("..").HiggsfieldContext, args: {
+        requestId: string;
+    }) => Promise<{
+        [x: string]: unknown;
+        status: string;
+        request_id: string;
+        status_url?: string | null | undefined;
+        cancel_url?: string | null | undefined;
+        error?: string | Record<string, unknown> | null | undefined;
+        expires_at?: string | null | undefined;
+        images?: {
+            [x: string]: unknown;
+            url?: string | null | undefined;
+            content_type?: string | null | undefined;
+        }[] | null | undefined;
+        video?: {
+            [x: string]: unknown;
+            url?: string | null | undefined;
+            content_type?: string | null | undefined;
+        } | null | undefined;
+        audio?: {
+            [x: string]: unknown;
+            url?: string | null | undefined;
+            content_type?: string | null | undefined;
+        } | null | undefined;
+        audios?: {
+            [x: string]: unknown;
+            url?: string | null | undefined;
+            content_type?: string | null | undefined;
+        }[] | null | undefined;
+    }>;
+    cancel: (ctx: import("..").HiggsfieldContext, args: {
+        requestId: string;
+    }) => Promise<{
+        request_id: string;
+        status: "canceled";
+    }>;
+    delete: (ctx: import("..").HiggsfieldContext, args: {
+        requestId: string;
+    }) => Promise<{
+        [x: string]: unknown;
+        request_id: string;
+        status: string;
+    }>;
+};
+export declare const Files: {
+    createUploadUrl: (ctx: import("..").HiggsfieldContext, args: {
+        contentType: "image/png" | "image/jpeg" | "image/jpg" | "image/gif" | "image/webp" | "audio/x-wav" | "audio/wav" | "audio/mpeg" | "audio/mp3" | "audio/mp4" | "audio/x-m4a" | "audio/aac" | "audio/ogg" | "audio/flac" | "audio/x-flac" | "audio/webm" | "video/mp4";
+    }) => Promise<{
+        [x: string]: unknown;
+        public_url: string;
+        upload_url: string;
+        content_type?: string | null | undefined;
+        upload_headers?: Record<string, string> | null | undefined;
+    }>;
+    upload: (ctx: import("..").HiggsfieldContext, args: {
+        contentBase64: string;
+        contentType: "image/png" | "image/jpeg" | "image/jpg" | "image/gif" | "image/webp" | "audio/x-wav" | "audio/wav" | "audio/mpeg" | "audio/mp3" | "audio/mp4" | "audio/x-m4a" | "audio/aac" | "audio/ogg" | "audio/flac" | "audio/x-flac" | "audio/webm" | "video/mp4";
+    }) => Promise<{
+        public_url: string;
+        content_type: string;
+        size: number;
+    }>;
+};
+export declare const Models: {
+    list: (ctx: import("..").HiggsfieldContext, args: {
+        search?: string | undefined;
+        outputType?: string | undefined;
+        operationType?: string | undefined;
+        includeSchema?: boolean | undefined;
+    }) => Promise<{
+        [x: string]: unknown;
+        items: {
+            [x: string]: unknown;
+            slug: string;
+            title?: string | null | undefined;
+            description?: string | null | undefined;
+            operation_type?: string[] | null | undefined;
+            output_type?: string | null | undefined;
+            base_credits?: string | null | undefined;
+            is_workflow?: boolean | null | undefined;
+            input_schema?: Record<string, unknown> | null | undefined;
+        }[];
+        total?: number | null | undefined;
+    }>;
+    get: (ctx: import("..").HiggsfieldContext, args: {
+        modelPath: string;
+    }) => Promise<{
+        [x: string]: unknown;
+        slug: string;
+        title?: string | null | undefined;
+        description?: string | null | undefined;
+        operation_type?: string[] | null | undefined;
+        output_type?: string | null | undefined;
+        base_credits?: string | null | undefined;
+        is_workflow?: boolean | null | undefined;
+        input_schema?: Record<string, unknown> | null | undefined;
+    }>;
+};
+export declare const Usage: {
+    get: (ctx: import("..").HiggsfieldContext, args: {
+        start?: string | undefined;
+        end?: string | undefined;
+        timeframe?: "hour" | "day" | "week" | "month" | undefined;
+        boundToTimeframe?: boolean | undefined;
+        models?: string[] | undefined;
+        byApiKey?: boolean | undefined;
+        page?: number | undefined;
+        limit?: number | undefined;
+    }) => Promise<{
+        [x: string]: unknown;
+        time_series?: {
+            [x: string]: unknown;
+            bucket: string;
+            results: {
+                [x: string]: unknown;
+                model?: string | null | undefined;
+                unit?: string | null | undefined;
+                quantity?: string | null | undefined;
+                unit_price?: string | null | undefined;
+                cost?: string | null | undefined;
+                currency?: string | null | undefined;
+                auth_method?: string | null | undefined;
+            }[];
+        }[] | null | undefined;
+        total?: number | null | undefined;
+        page?: number | null | undefined;
+        limit?: number | null | undefined;
+    }>;
+};
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/endpoints/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../endpoints/index.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIvB,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIpB,CAAC;AAEF,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;CAGjB,CAAC;AAEF,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGlB,CAAC;AAEF,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEjB,CAAC;AAEF,cAAc,SAAS,CAAC"}

package/dist/endpoints/models.d.ts

@@ -0,0 +1,4 @@
+import type { HiggsfieldEndpoints } from '../index';
+export declare const list: HiggsfieldEndpoints['modelsList'];
+export declare const get: HiggsfieldEndpoints['modelsGet'];
+//# sourceMappingURL=models.d.ts.map

package/dist/endpoints/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../endpoints/models.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAiDpD,eAAO,MAAM,IAAI,EAAE,mBAAmB,CAAC,YAAY,CAalD,CAAC;AAEF,eAAO,MAAM,GAAG,EAAE,mBAAmB,CAAC,WAAW,CAoBhD,CAAC"}

package/dist/endpoints/requests.d.ts

@@ -0,0 +1,6 @@
+import type { HiggsfieldEndpoints } from '../index';
+export declare const status: HiggsfieldEndpoints['requestsStatus'];
+/** 202 with an empty body while queued. Higgsfield answers 400 from the moment it starts, and also once it has finished. */
+export declare const cancel: HiggsfieldEndpoints['requestsCancel'];
+export declare const deleteRequest: HiggsfieldEndpoints['requestsDelete'];
+//# sourceMappingURL=requests.d.ts.map

package/dist/endpoints/requests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requests.d.ts","sourceRoot":"","sources":["../../endpoints/requests.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAMpD,eAAO,MAAM,MAAM,EAAE,mBAAmB,CAAC,gBAAgB,CAkBxD,CAAC;AAEF,4HAA4H;AAC5H,eAAO,MAAM,MAAM,EAAE,mBAAmB,CAAC,gBAAgB,CA6BxD,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,mBAAmB,CAAC,gBAAgB,CAiB/D,CAAC"}