@giveitsmaller/contracts 0.1.0 → 0.1.2

package/{openapi/runtime.ts → dist/openapi/runtime.js}

@@ -2,118 +2,88 @@
 /* eslint-disable */
 /**
  * GISL Compression API
- * REST API for the GISL (Give It Smaller) file compression and processing service.  **Architecture:** - Upload files to get a `file_id` - Create workflows referencing uploaded files with operations (compress, thumbnail, watermark, merge, archive, convert) - Poll status, stream SSE events, or receive webhook callbacks - Download results per operation output  **Response envelope:** All mutation and query endpoints return `{ success: true, data: {...} }` on success and `{ success: false, error: \"...\", details: [...] }` on failure. Exceptions: `GET /api/operations/schema` returns raw JSON (CDN-cacheable), health probes return flat objects, and `POST /api/contact` returns 204 with no body. 
+ * REST API for the GISL (Give It Smaller) file compression and processing service.  **Architecture:** - Upload files to get a `file_id` - Create workflows referencing uploaded files with operations (compress, thumbnail, watermark, merge, archive, convert) - Poll status, stream SSE events, or receive webhook callbacks - Download results per operation output  **Response envelope:** All mutation and query endpoints return `{ success: true, data: {...} }` on success and `{ success: false, error: \"...\", details: [...] }` on failure. Exceptions: `GET /api/operations/schema` returns raw JSON (CDN-cacheable), health probes return flat objects, and `POST /api/contact` returns 204 with no body.
  *
  * The version of the OpenAPI document: 2.0.0
- * 
+ *
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
-
-
 export const BASE_PATH = "http://localhost:8080".replace(/\/+$/, "");
-
-export interface ConfigurationParameters {
-    basePath?: string; // override base path
-    fetchApi?: FetchAPI; // override for fetch implementation
-    middleware?: Middleware[]; // middleware to apply before/after fetch requests
-    queryParamsStringify?: (params: HTTPQuery) => string; // stringify function for query strings
-    username?: string; // parameter for basic security
-    password?: string; // parameter for basic security
-    apiKey?: string | Promise<string> | ((name: string) => string | Promise<string>); // parameter for apiKey security
-    accessToken?: string | Promise<string> | ((name?: string, scopes?: string[]) => string | Promise<string>); // parameter for oauth2 security
-    headers?: HTTPHeaders; //header params we want to use on every request
-    credentials?: RequestCredentials; //value for the credentials param we want to use on each request
-}
-
 export class Configuration {
-    constructor(private configuration: ConfigurationParameters = {}) {}
-
-    set config(configuration: Configuration) {
+    configuration;
+    constructor(configuration = {}) {
+        this.configuration = configuration;
+    }
+    set config(configuration) {
         this.configuration = configuration;
     }
-
-    get basePath(): string {
+    get basePath() {
         return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH;
     }
-
-    get fetchApi(): FetchAPI | undefined {
+    get fetchApi() {
         return this.configuration.fetchApi;
     }
-
-    get middleware(): Middleware[] {
+    get middleware() {
         return this.configuration.middleware || [];
     }
-
-    get queryParamsStringify(): (params: HTTPQuery) => string {
+    get queryParamsStringify() {
         return this.configuration.queryParamsStringify || querystring;
     }
-
-    get username(): string | undefined {
+    get username() {
         return this.configuration.username;
     }
-
-    get password(): string | undefined {
+    get password() {
         return this.configuration.password;
     }
-
-    get apiKey(): ((name: string) => string | Promise<string>) | undefined {
+    get apiKey() {
         const apiKey = this.configuration.apiKey;
         if (apiKey) {
             return typeof apiKey === 'function' ? apiKey : () => apiKey;
         }
         return undefined;
     }
-
-    get accessToken(): ((name?: string, scopes?: string[]) => string | Promise<string>) | undefined {
+    get accessToken() {
         const accessToken = this.configuration.accessToken;
         if (accessToken) {
             return typeof accessToken === 'function' ? accessToken : async () => accessToken;
         }
         return undefined;
     }
-
-    get headers(): HTTPHeaders | undefined {
+    get headers() {
         return this.configuration.headers;
     }
-
-    get credentials(): RequestCredentials | undefined {
+    get credentials() {
         return this.configuration.credentials;
     }
 }
-
 export const DefaultConfig = new Configuration();
-
 /**
  * This is the base class for all generated API classes.
  */
 export class BaseAPI {
-
-    private static readonly jsonRegex = new RegExp('^(:?application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(:?;.*)?$', 'i');
-    private middleware: Middleware[];
-
-    constructor(protected configuration = DefaultConfig) {
+    configuration;
+    static jsonRegex = new RegExp('^(:?application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(:?;.*)?$', 'i');
+    middleware;
+    constructor(configuration = DefaultConfig) {
+        this.configuration = configuration;
         this.middleware = configuration.middleware;
     }
-
-    withMiddleware<T extends BaseAPI>(this: T, ...middlewares: Middleware[]) {
-        const next = this.clone<T>();
+    withMiddleware(...middlewares) {
+        const next = this.clone();
         next.middleware = next.middleware.concat(...middlewares);
         return next;
     }
-
-    withPreMiddleware<T extends BaseAPI>(this: T, ...preMiddlewares: Array<Middleware['pre']>) {
+    withPreMiddleware(...preMiddlewares) {
         const middlewares = preMiddlewares.map((pre) => ({ pre }));
-        return this.withMiddleware<T>(...middlewares);
+        return this.withMiddleware(...middlewares);
     }
-
-    withPostMiddleware<T extends BaseAPI>(this: T, ...postMiddlewares: Array<Middleware['post']>) {
+    withPostMiddleware(...postMiddlewares) {
         const middlewares = postMiddlewares.map((post) => ({ post }));
-        return this.withMiddleware<T>(...middlewares);
+        return this.withMiddleware(...middlewares);
     }
-
     /**
      * Check if the given MIME is a JSON MIME.
      * JSON MIME examples:
@@ -124,14 +94,13 @@ export class BaseAPI {
      * @param mime - MIME (Multipurpose Internet Mail Extensions)
      * @return True if the given MIME is JSON, false otherwise.
      */
-    protected isJsonMime(mime: string | null | undefined): boolean {
+    isJsonMime(mime) {
         if (!mime) {
             return false;
         }
         return BaseAPI.jsonRegex.test(mime);
     }
-
-    protected async request(context: RequestOpts, initOverrides?: RequestInit | InitOverrideFunction): Promise<Response> {
+    async request(context, initOverrides) {
         const { url, init } = await this.createFetchParams(context, initOverrides);
         const response = await this.fetchApi(url, init);
         if (response && (response.status >= 200 && response.status < 300)) {
@@ -139,8 +108,7 @@ export class BaseAPI {
         }
         throw new ResponseError(response, 'Response returned an error code');
     }
-
-    private async createFetchParams(context: RequestOpts, initOverrides?: RequestInit | InitOverrideFunction) {
+    async createFetchParams(context, initOverrides) {
         let url = this.configuration.basePath + context.path;
         if (context.query !== undefined && Object.keys(context.query).length !== 0) {
             // only add the querystring to the URL if there are query parameters.
@@ -148,50 +116,43 @@ export class BaseAPI {
             // do not handle correctly sometimes.
             url += '?' + this.configuration.queryParamsStringify(context.query);
         }
-
         const headers = Object.assign({}, this.configuration.headers, context.headers);
         Object.keys(headers).forEach(key => headers[key] === undefined ? delete headers[key] : {});
-
-        const initOverrideFn =
-            typeof initOverrides === "function"
-                ? initOverrides
-                : async () => initOverrides;
-
+        const initOverrideFn = typeof initOverrides === "function"
+            ? initOverrides
+            : async () => initOverrides;
         const initParams = {
             method: context.method,
             headers,
             body: context.body,
             credentials: this.configuration.credentials,
         };
-
-        const overriddenInit: RequestInit = {
+        const overriddenInit = {
             ...initParams,
             ...(await initOverrideFn({
                 init: initParams,
                 context,
             }))
         };
-
-        let body: any;
+        let body;
         if (isFormData(overriddenInit.body)
             || (overriddenInit.body instanceof URLSearchParams)
             || isBlob(overriddenInit.body)) {
-          body = overriddenInit.body;
-        } else if (this.isJsonMime(headers['Content-Type'])) {
-          body = JSON.stringify(overriddenInit.body);
-        } else {
-          body = overriddenInit.body;
+            body = overriddenInit.body;
+        }
+        else if (this.isJsonMime(headers['Content-Type'])) {
+            body = JSON.stringify(overriddenInit.body);
         }
-
-        const init: RequestInit = {
+        else {
+            body = overriddenInit.body;
+        }
+        const init = {
             ...overriddenInit,
             body
         };
-
         return { url, init };
     }
-
-    private fetchApi = async (url: string, init: RequestInit) => {
+    fetchApi = async (url, init) => {
         let fetchParams = { url, init };
         for (const middleware of this.middleware) {
             if (middleware.pre) {
@@ -201,10 +162,11 @@ export class BaseAPI {
                 }) || fetchParams;
             }
         }
-        let response: Response | undefined = undefined;
+        let response = undefined;
         try {
             response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
-        } catch (e) {
+        }
+        catch (e) {
             for (const middleware of this.middleware) {
                 if (middleware.onError) {
                     response = await middleware.onError({
@@ -217,11 +179,12 @@ export class BaseAPI {
                 }
             }
             if (response === undefined) {
-              if (e instanceof Error) {
-                throw new FetchError(e, 'The request failed and the interceptors did not return an alternative response');
-              } else {
-                throw e;
-              }
+                if (e instanceof Error) {
+                    throw new FetchError(e, 'The request failed and the interceptors did not return an alternative response');
+                }
+                else {
+                    throw e;
+                }
             }
         }
         for (const middleware of this.middleware) {
@@ -235,89 +198,62 @@ export class BaseAPI {
             }
         }
         return response;
-    }
-
+    };
     /**
      * Create a shallow clone of `this` by constructing a new instance
      * and then shallow cloning data members.
      */
-    private clone<T extends BaseAPI>(this: T): T {
-        const constructor = this.constructor as any;
+    clone() {
+        const constructor = this.constructor;
         const next = new constructor(this.configuration);
         next.middleware = this.middleware.slice();
         return next;
     }
-};
-
-function isBlob(value: any): value is Blob {
+}
+;
+function isBlob(value) {
     return typeof Blob !== 'undefined' && value instanceof Blob;
 }
-
-function isFormData(value: any): value is FormData {
+function isFormData(value) {
     return typeof FormData !== "undefined" && value instanceof FormData;
 }
-
 export class ResponseError extends Error {
-    override name: "ResponseError" = "ResponseError";
-    constructor(public response: Response, msg?: string) {
+    response;
+    name = "ResponseError";
+    constructor(response, msg) {
         super(msg);
+        this.response = response;
     }
 }
-
 export class FetchError extends Error {
-    override name: "FetchError" = "FetchError";
-    constructor(public cause: Error, msg?: string) {
+    cause;
+    name = "FetchError";
+    constructor(cause, msg) {
         super(msg);
+        this.cause = cause;
     }
 }
-
 export class RequiredError extends Error {
-    override name: "RequiredError" = "RequiredError";
-    constructor(public field: string, msg?: string) {
+    field;
+    name = "RequiredError";
+    constructor(field, msg) {
         super(msg);
+        this.field = field;
     }
 }
-
 export const COLLECTION_FORMATS = {
     csv: ",",
     ssv: " ",
     tsv: "\t",
     pipes: "|",
 };
-
-export type FetchAPI = WindowOrWorkerGlobalScope['fetch'];
-
-export type Json = any;
-export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
-export type HTTPHeaders = { [key: string]: string };
-export type HTTPQuery = { [key: string]: string | number | null | boolean | Array<string | number | null | boolean> | Set<string | number | null | boolean> | HTTPQuery };
-export type HTTPBody = Json | FormData | URLSearchParams;
-export type HTTPRequestInit = { headers?: HTTPHeaders; method: HTTPMethod; credentials?: RequestCredentials; body?: HTTPBody };
-export type ModelPropertyNaming = 'camelCase' | 'snake_case' | 'PascalCase' | 'original';
-
-export type InitOverrideFunction = (requestContext: { init: HTTPRequestInit, context: RequestOpts }) => Promise<RequestInit>
-
-export interface FetchParams {
-    url: string;
-    init: RequestInit;
-}
-
-export interface RequestOpts {
-    path: string;
-    method: HTTPMethod;
-    headers: HTTPHeaders;
-    query?: HTTPQuery;
-    body?: HTTPBody;
-}
-
-export function querystring(params: HTTPQuery, prefix: string = ''): string {
+export function querystring(params, prefix = '') {
     return Object.keys(params)
         .map(key => querystringSingleKey(key, params[key], prefix))
         .filter(part => part.length > 0)
         .join('&');
 }
-
-function querystringSingleKey(key: string, value: string | number | null | undefined | boolean | Array<string | number | null | boolean> | Set<string | number | null | boolean> | HTTPQuery, keyPrefix: string = ''): string {
+function querystringSingleKey(key, value, keyPrefix = '') {
     const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
     if (value instanceof Array) {
         const multiValue = value.map(singleValue => encodeURIComponent(String(singleValue)))
@@ -332,25 +268,22 @@ function querystringSingleKey(key: string, value: string | number | null | undef
         return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
     }
     if (value instanceof Object) {
-        return querystring(value as HTTPQuery, fullKey);
+        return querystring(value, fullKey);
     }
     return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
 }
-
-export function exists(json: any, key: string) {
+export function exists(json, key) {
     const value = json[key];
     return value !== null && value !== undefined;
 }
-
-export function mapValues(data: any, fn: (item: any) => any) {
-    const result: { [key: string]: any } = {};
+export function mapValues(data, fn) {
+    const result = {};
     for (const key of Object.keys(data)) {
         result[key] = fn(data[key]);
     }
     return result;
 }
-
-export function canConsumeForm(consumes: Consume[]): boolean {
+export function canConsumeForm(consumes) {
     for (const consume of consumes) {
         if ('multipart/form-data' === consume.contentType) {
             return true;
@@ -358,75 +291,43 @@ export function canConsumeForm(consumes: Consume[]): boolean {
     }
     return false;
 }
-
-export interface Consume {
-    contentType: string;
-}
-
-export interface RequestContext {
-    fetch: FetchAPI;
-    url: string;
-    init: RequestInit;
-}
-
-export interface ResponseContext {
-    fetch: FetchAPI;
-    url: string;
-    init: RequestInit;
-    response: Response;
-}
-
-export interface ErrorContext {
-    fetch: FetchAPI;
-    url: string;
-    init: RequestInit;
-    error: unknown;
-    response?: Response;
-}
-
-export interface Middleware {
-    pre?(context: RequestContext): Promise<FetchParams | void>;
-    post?(context: ResponseContext): Promise<Response | void>;
-    onError?(context: ErrorContext): Promise<Response | void>;
-}
-
-export interface ApiResponse<T> {
-    raw: Response;
-    value(): Promise<T>;
-}
-
-export interface ResponseTransformer<T> {
-    (json: any): T;
-}
-
-export class JSONApiResponse<T> {
-    constructor(public raw: Response, private transformer: ResponseTransformer<T> = (jsonValue: any) => jsonValue) {}
-
-    async value(): Promise<T> {
+export class JSONApiResponse {
+    raw;
+    transformer;
+    constructor(raw, transformer = (jsonValue) => jsonValue) {
+        this.raw = raw;
+        this.transformer = transformer;
+    }
+    async value() {
         return this.transformer(await this.raw.json());
     }
 }
-
 export class VoidApiResponse {
-    constructor(public raw: Response) {}
-
-    async value(): Promise<void> {
+    raw;
+    constructor(raw) {
+        this.raw = raw;
+    }
+    async value() {
         return undefined;
     }
 }
-
 export class BlobApiResponse {
-    constructor(public raw: Response) {}
-
-    async value(): Promise<Blob> {
+    raw;
+    constructor(raw) {
+        this.raw = raw;
+    }
+    async value() {
         return await this.raw.blob();
-    };
+    }
+    ;
 }
-
 export class TextApiResponse {
-    constructor(public raw: Response) {}
-
-    async value(): Promise<string> {
+    raw;
+    constructor(raw) {
+        this.raw = raw;
+    }
+    async value() {
         return await this.raw.text();
-    };
+    }
+    ;
 }

package/dist/operations/archive.d.ts

@@ -0,0 +1,12 @@
+export declare enum ArchiveFormat {
+    Zip = "zip",
+    TarGz = "tar.gz"
+}
+export declare enum ArchiveFolderStructure {
+    Flat = "flat",
+    ByJob = "by_job"
+}
+export interface ArchiveOptions {
+    format?: ArchiveFormat;
+    folder_structure?: ArchiveFolderStructure;
+}

package/dist/operations/archive.js

@@ -0,0 +1,11 @@
+// Auto-generated from archive.yaml -- do not edit
+export var ArchiveFormat;
+(function (ArchiveFormat) {
+    ArchiveFormat["Zip"] = "zip";
+    ArchiveFormat["TarGz"] = "tar.gz";
+})(ArchiveFormat || (ArchiveFormat = {}));
+export var ArchiveFolderStructure;
+(function (ArchiveFolderStructure) {
+    ArchiveFolderStructure["Flat"] = "flat";
+    ArchiveFolderStructure["ByJob"] = "by_job";
+})(ArchiveFolderStructure || (ArchiveFolderStructure = {}));

package/dist/operations/compress.d.ts

@@ -0,0 +1,154 @@
+export declare enum CompressImageMode {
+    Lossy = "lossy",
+    Lossless = "lossless",
+    Auto = "auto"
+}
+export declare enum CompressImageFit {
+    Max = "max",
+    Crop = "crop",
+    Scale = "scale"
+}
+export declare enum CompressImageMetadata {
+    All = "all",
+    None = "none",
+    Copyright = "copyright",
+    Sensitive = "sensitive"
+}
+export declare enum CompressImageIccProfile {
+    Preserve = "preserve",
+    Strip = "strip",
+    Srgb = "srgb"
+}
+export declare enum CompressImageOutputFormat {
+    Original = "original",
+    Auto = "auto",
+    Smallest = "smallest",
+    Jpeg = "jpeg",
+    Png = "png",
+    Webp = "webp",
+    Avif = "avif"
+}
+export interface CompressImageOptions {
+    mode?: CompressImageMode;
+    quality?: number;
+    width?: number;
+    height?: number;
+    fit?: CompressImageFit;
+    metadata?: CompressImageMetadata;
+    icc_profile?: CompressImageIccProfile;
+    auto_orient?: boolean;
+    progressive?: boolean;
+    output_format?: CompressImageOutputFormat;
+}
+export declare enum CompressAudioBitrate {
+    _64 = 64,
+    _96 = 96,
+    _128 = 128,
+    _192 = 192,
+    _256 = 256,
+    _320 = 320
+}
+export declare enum CompressAudioSampleRate {
+    _22050 = 22050,
+    _44100 = 44100,
+    _48000 = 48000
+}
+export interface CompressAudioOptions {
+    bitrate?: CompressAudioBitrate;
+    channels?: number;
+    sample_rate?: CompressAudioSampleRate;
+    normalize?: boolean;
+    trim_start?: number;
+    trim_end?: number;
+}
+export declare enum CompressVideoCodec {
+    H264 = "h264",
+    H265 = "h265",
+    Vp9 = "vp9",
+    Av1 = "av1"
+}
+export declare enum CompressVideoEncodingMode {
+    Crf = "crf",
+    TargetSize = "target_size"
+}
+export declare enum CompressVideoPreset {
+    Ultrafast = "ultrafast",
+    Superfast = "superfast",
+    Veryfast = "veryfast",
+    Faster = "faster",
+    Fast = "fast",
+    Medium = "medium",
+    Slow = "slow",
+    Slower = "slower",
+    Veryslow = "veryslow"
+}
+export declare enum CompressVideoFit {
+    Max = "max",
+    Crop = "crop",
+    Scale = "scale",
+    Pad = "pad"
+}
+export declare enum CompressVideoAudioCodec {
+    Aac = "aac",
+    Opus = "opus",
+    Vorbis = "vorbis",
+    Copy = "copy"
+}
+export declare enum CompressVideoAudioBitrate {
+    _64 = 64,
+    _96 = 96,
+    _128 = 128,
+    _192 = 192,
+    _256 = 256,
+    _320 = 320
+}
+export interface CompressVideoOptions {
+    codec?: CompressVideoCodec;
+    encoding_mode?: CompressVideoEncodingMode;
+    crf?: number;
+    target_size_bytes?: number;
+    preset?: CompressVideoPreset;
+    width?: number;
+    height?: number;
+    fit?: CompressVideoFit;
+    fps?: number;
+    faststart?: boolean;
+    audio_codec?: CompressVideoAudioCodec;
+    audio_bitrate?: CompressVideoAudioBitrate;
+    trim_start?: number;
+    trim_end?: number;
+}
+export declare enum CompressDocumentPdfProfile {
+    Web = "web",
+    Print = "print",
+    Archive = "archive",
+    Max = "max"
+}
+export declare enum CompressDocumentPdfColorspace {
+    Unchanged = "unchanged",
+    Rgb = "rgb",
+    Cmyk = "cmyk",
+    Grayscale = "grayscale"
+}
+export interface CompressDocumentPdfOptions {
+    profile?: CompressDocumentPdfProfile;
+    colorspace?: CompressDocumentPdfColorspace;
+    pages?: string;
+    flatten_forms?: boolean;
+}
+export interface CompressDocumentOfficeOptions {
+    image_quality?: number;
+    strip_macros?: boolean;
+    strip_hidden_data?: boolean;
+    strip_unused_fonts?: boolean;
+}
+export interface CompressDocumentOdfOptions {
+    image_quality?: number;
+    strip_metadata?: boolean;
+    strip_unused_styles?: boolean;
+}
+export interface CompressDocumentEpubOptions {
+    image_quality?: number;
+    font_subsetting?: boolean;
+    strip_unused_css?: boolean;
+}