/*! Pixonaut SDK type declarations. Licensed under the MIT licence: see LICENSE-MIT. */
import { paths } from './schema.js';

/** What `P`'s `GET` answers, as JSON. */
export declare type AnswerOf<P extends ReadPath> = ReadOf<P> extends {
    responses: {
        200: {
            content: {
                "application/json": infer A;
            };
        };
    };
} ? A : never;

/** What every bundle's `PixonautApiError` marks its refusals with: a
 *  registered symbol, the same in each. */
declare const API_ERROR_BRAND: unique symbol;

export declare interface ClientOptions {
    /** The key every read is made with. A secret or integration key only on a
     *  server; in a browser, a publishable key. */
    key: string;
    /** The API's address, such as `https://api.pixonaut.app`. */
    baseUrl: string;
    /** The `fetch` reads are made with; the platform's own when omitted. */
    fetch?: typeof fetch;
    /** The designer session reads are made in, sent as `x-pixonaut-session`.
     *  A publishable key reads a shopper's upload only in the session it was
     *  uploaded in. */
    session?: string;
}

/** A client reading as `key`. In a browser, a key that must stay on a server
 *  is refused here, before it is sent anywhere. */
export declare function createClient(opts: ClientOptions): PixonautClient;

/** A method for every published `GET` operation, named from its
 *  operationId, over `json` (an answer read as JSON) and `raw` (an answer
 *  handed over as it came: a picture or a PDF). */
declare function operations({ json, raw }: Reads): {
    apiKeys: {
        /** List the tenant's API keys */
        list: () => Promise<AnswerOf<"/v1/api-keys">>;
    };
    assetCategories: {
        /** List asset categories */
        list: (query?: QueryOf<"/v1/asset-categories">) => Promise<AnswerOf<"/v1/asset-categories">>;
    };
    assetFilters: {
        /** List the values the asset listing can filter on */
        list: () => Promise<AnswerOf<"/v1/asset-filters">>;
    };
    assets: {
        /** Check whether the tenant already stores a file */
        checkDuplicate: (sha256hex: string) => Promise<AnswerOf<"/v1/asset-duplicate/{sha256hex}">>;
        content: {
            /** Fetch an asset's preview */
            get: (id: string, query?: QueryOf<"/v1/assets/{id}/content">) => Promise<Response>;
        };
        /** Read an asset */
        get: (id: string) => Promise<AnswerOf<"/v1/assets/{id}">>;
        /** List assets */
        list: (query?: QueryOf<"/v1/assets">) => Promise<AnswerOf<"/v1/assets">>;
        original: {
            /** Fetch an asset's file */
            get: (id: string) => Promise<Response>;
        };
        usage: {
            /** Where an asset is used */
            get: (id: string) => Promise<AnswerOf<"/v1/assets/{id}/usage">>;
        };
    };
    assetTags: {
        /** List asset tags */
        list: (query?: QueryOf<"/v1/asset-tags">) => Promise<AnswerOf<"/v1/asset-tags">>;
    };
    automations: {
        /** Read one of an automation's firings */
        firing: (id: string, firingId: string) => Promise<AnswerOf<"/v1/automations/{id}/firings/{firingId}">>;
        /** List an automation's firings */
        firings: (id: string, query?: QueryOf<"/v1/automations/{id}/firings">) => Promise<AnswerOf<"/v1/automations/{id}/firings">>;
        /** Read an automation */
        get: (id: string) => Promise<AnswerOf<"/v1/automations/{id}">>;
        /** List the workspace's automations */
        list: (query?: QueryOf<"/v1/automations">) => Promise<AnswerOf<"/v1/automations">>;
        /** List the placeholders an automation may write */
        placeholders: () => Promise<AnswerOf<"/v1/automations/placeholders">>;
        /** List an automation's versions */
        versions: (id: string, query?: QueryOf<"/v1/automations/{id}/versions">) => Promise<AnswerOf<"/v1/automations/{id}/versions">>;
    };
    blanks: {
        /** Read a blank */
        get: (id: string) => Promise<AnswerOf<"/v1/blanks/{id}">>;
        /** List the tenant's blanks */
        list: (query?: QueryOf<"/v1/blanks">) => Promise<AnswerOf<"/v1/blanks">>;
        mockups: {
            /** List a blank's placements, views and mockups */
            list: (id: string) => Promise<AnswerOf<"/v1/blanks/{id}/mockups">>;
        };
        placements: {
            fittingTemplates: {
                /** List the templates that fit a placement */
                list: (id: string, placementId: string, query?: QueryOf<"/v1/blanks/{id}/placements/{placementId}/fitting-templates">) => Promise<AnswerOf<"/v1/blanks/{id}/placements/{placementId}/fitting-templates">>;
            };
        };
        previewTables: {
            /** Read the colour tables a design on a placement is drawn through */
            get: (id: string, placementId: string) => Promise<AnswerOf<"/v1/blanks/{id}/placements/{placementId}/preview-tables">>;
        };
        variants: {
            /** List a blank's variants */
            list: (id: string) => Promise<AnswerOf<"/v1/blanks/{id}/variants">>;
        };
    };
    connectedStore: {
        /** Read this store's connection */
        get: () => Promise<AnswerOf<"/v1/connect">>;
    };
    customerSessions: {
        /** Inspect a customer session's uploads and proofs */
        get: (id: string) => Promise<AnswerOf<"/v1/admin/sessions/{id}">>;
    };
    designs: {
        delivery: {
            /** Read who a design's first order is for and where it ships */
            get: (id: string) => Promise<AnswerOf<"/v1/designs/{id}/delivery">>;
        };
        designer: {
            /** Open a design in the designer to correct it */
            get: (id: string) => Promise<AnswerOf<"/v1/designs/{id}/designer">>;
        };
        /** Read one design */
        get: (id: string) => Promise<AnswerOf<"/v1/designs/{id}">>;
        /** List the tenant's designs, newest first */
        list: (query?: QueryOf<"/v1/designs">) => Promise<AnswerOf<"/v1/designs">>;
        proof: {
            /** Fetch a design's proof image */
            get: (id: string, query?: QueryOf<"/v1/designs/{id}/proof">) => Promise<Response>;
        };
        review: {
            /** Read a design as its customer reviews it */
            get: (id: string) => Promise<AnswerOf<"/v1/designs/{id}/review">>;
        };
        revisions: {
            /** Read one revision of a design */
            get: (id: string, revision: string) => Promise<AnswerOf<"/v1/designs/{id}/revisions/{revision}">>;
            image: {
                /** Draw a revision of a design */
                get: (id: string, revision: string, query?: QueryOf<"/v1/designs/{id}/revisions/{revision}/image">) => Promise<Response>;
            };
            /** List a design's revisions */
            list: (id: string, query?: QueryOf<"/v1/designs/{id}/revisions">) => Promise<AnswerOf<"/v1/designs/{id}/revisions">>;
        };
    };
    events: {
        /** Pull the tenant's events after a given one */
        list: (query?: QueryOf<"/v1/events">) => Promise<AnswerOf<"/v1/events">>;
    };
    orders: {
        deliveries: {
            /** Read an order's step delivery log */
            list: (id: string) => Promise<AnswerOf<"/v1/orders/{id}/deliveries">>;
        };
        /** Read one order, with its history */
        get: (id: string) => Promise<AnswerOf<"/v1/orders/{id}">>;
        job: {
            files: {
                /** Fetch the print file of an order */
                get: (id: string, query?: QueryOf<"/v1/orders/{id}/job/file">) => Promise<Response>;
                /** List the files an order can be fetched as */
                list: (id: string, query?: QueryOf<"/v1/orders/{id}/job/files">) => Promise<AnswerOf<"/v1/orders/{id}/job/files">>;
            };
            /** Read an order as its printshop makes it */
            get: (id: string, query?: QueryOf<"/v1/orders/{id}/job">) => Promise<AnswerOf<"/v1/orders/{id}/job">>;
        };
        /** List the tenant's orders, newest first */
        list: (query?: QueryOf<"/v1/orders">) => Promise<AnswerOf<"/v1/orders">>;
        progress: {
            /** Read an order as its customer follows it */
            get: (id: string) => Promise<AnswerOf<"/v1/orders/{id}/progress">>;
        };
        /** List the blanks a failed order could be sent to */
        rerouteTargets: (id: string, query?: QueryOf<"/v1/orders/{id}/reroute-targets">) => Promise<AnswerOf<"/v1/orders/{id}/reroute-targets">>;
    };
    prints: {
        files: {
            /** Fetch a print's file */
            get: (id: string, query?: QueryOf<"/v1/prints/{id}/file">) => Promise<Response>;
            /** List the files a print can be fetched as */
            list: (id: string, query?: QueryOf<"/v1/prints/{id}/files">) => Promise<AnswerOf<"/v1/prints/{id}/files">>;
        };
        /** Read one print */
        get: (id: string) => Promise<AnswerOf<"/v1/prints/{id}">>;
        /** List the tenant's prints, newest first */
        list: (query?: QueryOf<"/v1/prints">) => Promise<AnswerOf<"/v1/prints">>;
    };
    printshopConnections: {
        /** List the tenant's printshop connections */
        list: (query?: QueryOf<"/v1/printshop-connections">) => Promise<AnswerOf<"/v1/printshop-connections">>;
    };
    shareLinks: {
        /** List the tenant's share links */
        list: (query?: QueryOf<"/v1/share-links">) => Promise<AnswerOf<"/v1/share-links">>;
    };
    storage: {
        /** Read the tenant's storage use */
        get: () => Promise<AnswerOf<"/v1/storage">>;
    };
    templates: {
        constraints: {
            /** Read what a print size of a template is judged against */
            get: (id: string, query?: QueryOf<"/v1/templates/{id}/constraints">) => Promise<AnswerOf<"/v1/templates/{id}/constraints">>;
        };
        fittingPlacements: {
            /** List the blank placements a template fits */
            list: (id: string, query?: QueryOf<"/v1/templates/{id}/fitting-blanks">) => Promise<AnswerOf<"/v1/templates/{id}/fitting-blanks">>;
        };
        /** Read a published template */
        get: (id: string) => Promise<AnswerOf<"/v1/templates/{id}">>;
        /** List the tenant's templates */
        list: (query?: QueryOf<"/v1/templates">) => Promise<AnswerOf<"/v1/templates">>;
    };
    webhookEndpoints: {
        deliveries: {
            /** List an endpoint's recent deliveries */
            list: (id: string) => Promise<AnswerOf<"/v1/webhooks/{id}/deliveries">>;
        };
        /** List the tenant's webhook endpoints */
        list: () => Promise<AnswerOf<"/v1/webhooks">>;
    };
};

/** A path's `{name}` segments, by name. */
declare type PathParams = Record<string, string | number>;

/** A refusal from Pixonaut's API. `status` is the contract a host branches
 *  on (an expired link's 401, a paused template's 404, a throttled visitor's
 *  429, an outage's 5xx); `code` is the server's `error`, as its error codes
 *  list it, when its body names one; `requestId` names the request to
 *  Pixonaut's support, when the response carried one. */
export declare class PixonautApiError extends Error {
    /** Whether `value` is a refusal from any of the SDK's bundles. Each entry
     *  (client, core, the whole SDK) carries its own copy of this class, so a
     *  refusal is told by its brand rather than by which copy made it: one
     *  imported from the client catches the designer's refusals too. */
    static [Symbol.hasInstance](value: unknown): boolean;
    readonly [API_ERROR_BRAND] = true;
    readonly status: number;
    readonly code?: string;
    readonly requestId?: string;
    /** what the design breaks, on a 422 that is a validation failure; the same
     *  list `onValidation` was handed */
    readonly violations?: RemoteViolation[];
    /** The side refused, when `approve()` or `commit()` made a design of
     *  several (#1364): its placement. */
    placementId?: string;
    /** On a `link_design_limit` refusal: when the share link makes designs
     *  again, in epoch milliseconds, or null for a limit in total, which never
     *  reopens. */
    readonly reopensAt?: number | null;
    constructor(message: string, status: number, detail?: {
        code?: string;
        violations?: RemoteViolation[];
        requestId?: string;
        reopensAt?: number | null;
    });
}

/** The client: a method for every published `GET` operation, named from its
 *  operationId (`client.templates.get(id)`). */
export declare type PixonautClient = ReturnType<typeof operations>;

/** The query `P`'s `GET` takes. */
export declare type QueryOf<P extends ReadPath> = ReadOf<P> extends {
    parameters: {
        query?: infer Q;
    };
} ? NonNullable<Q> : never;

declare type ReadOf<P extends ReadPath> = paths[P] extends {
    get: infer O;
} ? O : never;

/** A path the reference serves a `GET` at. */
export declare type ReadPath = {
    [P in keyof paths]: paths[P] extends {
        get: object;
    } ? P : never;
}[keyof paths];

declare interface Reads {
    /** `GET` `path` with `params` and `query`, and read its answer as JSON. */
    json<P extends ReadPath>(path: P, params: PathParams, query?: QueryOf<P>): Promise<AnswerOf<P>>;
    /** `GET` `path` with `params` and `query`, and hand its answer over as it
     *  came: a picture or a PDF, for the caller to stream or save. */
    raw<P extends ReadPath>(path: P, params: PathParams, query?: QueryOf<P>): Promise<Response>;
}

/** A constraint failure as it arrives from the API, which strips `allowed`
 *  before responding (issue #61, ADR 016 Amendment 3).
 *
 *  Anything fed by BOTH paths — `onValidation`, notably — is typed as this, so
 *  an embedder reading `allowed` off it gets a compile error rather than
 *  `undefined` at runtime from the network path.
 *
 *  Deliberately a plain `Omit` and NOT a branded type, unlike the API's
 *  `PublicViolation`: a WASM `Violation` must remain assignable here, since the
 *  local path really does hand one to the same callback. That means this type
 *  documents intent rather than enforcing absence — it stops a consumer relying
 *  on the field, not a producer including it. The enforcement that matters
 *  happens server-side, where the field is actually removed. */
declare type RemoteViolation = Omit<Violation, "allowed">;

/** A constraint failure as the WASM core emits it, `allowed` included. Only
 *  the local path produces these: the browser already holds the template, so
 *  restating one of its rules discloses nothing it did not send. */
declare interface Violation {
    layerId: string;
    prop: string;
    rule: string;
    given: unknown;
    allowed: unknown;
    /** `error` refuses a publish; `warning` never does (ADR 193). */
    severity: "error" | "warning";
}

export { }