@leonardo-ai/sdk 4.3.0 → 4.3.1

package/src/sdk/generation.ts

@@ -458,6 +458,85 @@ export class Generation extends ClientSDK {
         }
     }
 
+    /**
+     * Create LCM Generation
+     *
+     * @remarks
+     * This endpoint will generate a LCM image generation.
+     */
+    async postGenerationsLcm(
+        input: operations.PostGenerationsLcmRequestBody | undefined,
+        options?: RequestOptions
+    ): Promise<operations.PostGenerationsLcmResponse> {
+        const headers$ = new Headers();
+        headers$.set("user-agent", SDK_METADATA.userAgent);
+        headers$.set("Content-Type", "application/json");
+        headers$.set("Accept", "application/json");
+
+        const payload$ = schemas$.parse(
+            input,
+            (value$) =>
+                operations.PostGenerationsLcmRequestBody$.outboundSchema.optional().parse(value$),
+            "Input validation failed"
+        );
+        const body$ =
+            payload$ === undefined ? null : enc$.encodeJSON("body", payload$, { explode: true });
+
+        const path$ = this.templateURLComponent("/generations-lcm")();
+
+        const query$ = "";
+
+        let security$;
+        if (typeof this.options$.bearerAuth === "function") {
+            security$ = { bearerAuth: await this.options$.bearerAuth() };
+        } else if (this.options$.bearerAuth) {
+            security$ = { bearerAuth: this.options$.bearerAuth };
+        } else {
+            security$ = {};
+        }
+        const securitySettings$ = this.resolveGlobalSecurity(security$);
+
+        const context = { operationID: "post_/generations-lcm" };
+        const doOptions = { context, errorCodes: [] };
+        const request = this.createRequest$(
+            {
+                security: securitySettings$,
+                method: "POST",
+                path: path$,
+                headers: headers$,
+                query: query$,
+                body: body$,
+            },
+            options
+        );
+
+        const response = await this.do$(request, doOptions);
+
+        const responseFields$ = {
+            ContentType: response.headers.get("content-type") ?? "application/octet-stream",
+            StatusCode: response.status,
+            RawResponse: response,
+        };
+
+        if (this.matchResponse(response, 200, "application/json")) {
+            const responseBody = await response.json();
+            const result = schemas$.parse(
+                responseBody,
+                (val$) => {
+                    return operations.PostGenerationsLcmResponse$.inboundSchema.parse({
+                        ...responseFields$,
+                        object: val$,
+                    });
+                },
+                "Response validation failed"
+            );
+            return result;
+        } else {
+            const responseBody = await response.text();
+            throw new errors.SDKError("Unexpected API response", response, responseBody);
+        }
+    }
+
     /**
      * Create SVD Motion Generation
      *
@@ -619,4 +698,241 @@ export class Generation extends ClientSDK {
             throw new errors.SDKError("Unexpected API response", response, responseBody);
         }
     }
+
+    /**
+     * Perform inpainting on a LCM image
+     *
+     * @remarks
+     * This endpoint will perform a inpainting on a LCM image
+     */
+    async postLcmInpainting(
+        input: operations.PostLcmInpaintingRequestBody | undefined,
+        options?: RequestOptions
+    ): Promise<operations.PostLcmInpaintingResponse> {
+        const headers$ = new Headers();
+        headers$.set("user-agent", SDK_METADATA.userAgent);
+        headers$.set("Content-Type", "application/json");
+        headers$.set("Accept", "application/json");
+
+        const payload$ = schemas$.parse(
+            input,
+            (value$) =>
+                operations.PostLcmInpaintingRequestBody$.outboundSchema.optional().parse(value$),
+            "Input validation failed"
+        );
+        const body$ =
+            payload$ === undefined ? null : enc$.encodeJSON("body", payload$, { explode: true });
+
+        const path$ = this.templateURLComponent("/lcm-inpainting")();
+
+        const query$ = "";
+
+        let security$;
+        if (typeof this.options$.bearerAuth === "function") {
+            security$ = { bearerAuth: await this.options$.bearerAuth() };
+        } else if (this.options$.bearerAuth) {
+            security$ = { bearerAuth: this.options$.bearerAuth };
+        } else {
+            security$ = {};
+        }
+        const securitySettings$ = this.resolveGlobalSecurity(security$);
+
+        const context = { operationID: "post_/lcm-inpainting" };
+        const doOptions = { context, errorCodes: [] };
+        const request = this.createRequest$(
+            {
+                security: securitySettings$,
+                method: "POST",
+                path: path$,
+                headers: headers$,
+                query: query$,
+                body: body$,
+            },
+            options
+        );
+
+        const response = await this.do$(request, doOptions);
+
+        const responseFields$ = {
+            ContentType: response.headers.get("content-type") ?? "application/octet-stream",
+            StatusCode: response.status,
+            RawResponse: response,
+        };
+
+        if (this.matchResponse(response, 200, "application/json")) {
+            const responseBody = await response.json();
+            const result = schemas$.parse(
+                responseBody,
+                (val$) => {
+                    return operations.PostLcmInpaintingResponse$.inboundSchema.parse({
+                        ...responseFields$,
+                        object: val$,
+                    });
+                },
+                "Response validation failed"
+            );
+            return result;
+        } else {
+            const responseBody = await response.text();
+            throw new errors.SDKError("Unexpected API response", response, responseBody);
+        }
+    }
+
+    /**
+     * Perform instant refine on a LCM image
+     *
+     * @remarks
+     * This endpoint will perform instant refine on a LCM image
+     */
+    async postLcmInstantRefine(
+        input: operations.PostLcmInstantRefineRequestBody | undefined,
+        options?: RequestOptions
+    ): Promise<operations.PostLcmInstantRefineResponse> {
+        const headers$ = new Headers();
+        headers$.set("user-agent", SDK_METADATA.userAgent);
+        headers$.set("Content-Type", "application/json");
+        headers$.set("Accept", "application/json");
+
+        const payload$ = schemas$.parse(
+            input,
+            (value$) =>
+                operations.PostLcmInstantRefineRequestBody$.outboundSchema.optional().parse(value$),
+            "Input validation failed"
+        );
+        const body$ =
+            payload$ === undefined ? null : enc$.encodeJSON("body", payload$, { explode: true });
+
+        const path$ = this.templateURLComponent("/lcm-instant-refine")();
+
+        const query$ = "";
+
+        let security$;
+        if (typeof this.options$.bearerAuth === "function") {
+            security$ = { bearerAuth: await this.options$.bearerAuth() };
+        } else if (this.options$.bearerAuth) {
+            security$ = { bearerAuth: this.options$.bearerAuth };
+        } else {
+            security$ = {};
+        }
+        const securitySettings$ = this.resolveGlobalSecurity(security$);
+
+        const context = { operationID: "post_/lcm-instant-refine" };
+        const doOptions = { context, errorCodes: [] };
+        const request = this.createRequest$(
+            {
+                security: securitySettings$,
+                method: "POST",
+                path: path$,
+                headers: headers$,
+                query: query$,
+                body: body$,
+            },
+            options
+        );
+
+        const response = await this.do$(request, doOptions);
+
+        const responseFields$ = {
+            ContentType: response.headers.get("content-type") ?? "application/octet-stream",
+            StatusCode: response.status,
+            RawResponse: response,
+        };
+
+        if (this.matchResponse(response, 200, "application/json")) {
+            const responseBody = await response.json();
+            const result = schemas$.parse(
+                responseBody,
+                (val$) => {
+                    return operations.PostLcmInstantRefineResponse$.inboundSchema.parse({
+                        ...responseFields$,
+                        object: val$,
+                    });
+                },
+                "Response validation failed"
+            );
+            return result;
+        } else {
+            const responseBody = await response.text();
+            throw new errors.SDKError("Unexpected API response", response, responseBody);
+        }
+    }
+
+    /**
+     * Perform Alchemy Upscale on a LCM image
+     *
+     * @remarks
+     * This endpoint will perform Alchemy Upscale on a LCM image
+     */
+    async postLcmUpscale(
+        input: operations.PostLcmUpscaleRequestBody | undefined,
+        options?: RequestOptions
+    ): Promise<operations.PostLcmUpscaleResponse> {
+        const headers$ = new Headers();
+        headers$.set("user-agent", SDK_METADATA.userAgent);
+        headers$.set("Content-Type", "application/json");
+        headers$.set("Accept", "application/json");
+
+        const payload$ = schemas$.parse(
+            input,
+            (value$) =>
+                operations.PostLcmUpscaleRequestBody$.outboundSchema.optional().parse(value$),
+            "Input validation failed"
+        );
+        const body$ =
+            payload$ === undefined ? null : enc$.encodeJSON("body", payload$, { explode: true });
+
+        const path$ = this.templateURLComponent("/lcm-upscale")();
+
+        const query$ = "";
+
+        let security$;
+        if (typeof this.options$.bearerAuth === "function") {
+            security$ = { bearerAuth: await this.options$.bearerAuth() };
+        } else if (this.options$.bearerAuth) {
+            security$ = { bearerAuth: this.options$.bearerAuth };
+        } else {
+            security$ = {};
+        }
+        const securitySettings$ = this.resolveGlobalSecurity(security$);
+
+        const context = { operationID: "post_/lcm-upscale" };
+        const doOptions = { context, errorCodes: [] };
+        const request = this.createRequest$(
+            {
+                security: securitySettings$,
+                method: "POST",
+                path: path$,
+                headers: headers$,
+                query: query$,
+                body: body$,
+            },
+            options
+        );
+
+        const response = await this.do$(request, doOptions);
+
+        const responseFields$ = {
+            ContentType: response.headers.get("content-type") ?? "application/octet-stream",
+            StatusCode: response.status,
+            RawResponse: response,
+        };
+
+        if (this.matchResponse(response, 200, "application/json")) {
+            const responseBody = await response.json();
+            const result = schemas$.parse(
+                responseBody,
+                (val$) => {
+                    return operations.PostLcmUpscaleResponse$.inboundSchema.parse({
+                        ...responseFields$,
+                        object: val$,
+                    });
+                },
+                "Response validation failed"
+            );
+            return result;
+        } else {
+            const responseBody = await response.text();
+            throw new errors.SDKError("Unexpected API response", response, responseBody);
+        }
+    }
 }

package/src/sdk/models/operations/index.ts

@@ -22,8 +22,12 @@ export * from "./getmodelbyid";
 export * from "./getplatformmodels";
 export * from "./getuserself";
 export * from "./getvariationbyid";
+export * from "./postgenerationslcm";
 export * from "./postgenerationsmotionsvd";
 export * from "./postgenerationstexture";
+export * from "./postlcminpainting";
+export * from "./postlcminstantrefine";
+export * from "./postlcmupscale";
 export * from "./postmodels3dupload";
 export * from "./postvariationsunzoom";
 export * from "./uploaddatasetimage";

package/src/sdk/models/operations/postgenerationslcm.ts

@@ -0,0 +1,309 @@
+/*
+ * Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+ */
+
+import * as shared from "../../../sdk/models/shared";
+import { z } from "zod";
+
+/**
+ * Query parameters can also be provided in the request body as a JSON object
+ */
+export type PostGenerationsLcmRequestBody = {
+    /**
+     * How strongly the generation should reflect the prompt. Must be a float between 0.5 and 20.
+     */
+    guidance?: number | null | undefined;
+    /**
+     * The output width of the image. Must be 512, 640 or 1024.
+     */
+    height?: number | null | undefined;
+    /**
+     * Image data used to generate image. In base64 format. Prefix: `data:image/jpeg;base64,`
+     */
+    imageDataUrl: string;
+    /**
+     * The prompt used to generate images
+     */
+    prompt: string;
+    requestTimestamp?: string | undefined;
+    seed?: number | null | undefined;
+    /**
+     * The number of steps to use for the generation. Must be between 4 and 16.
+     */
+    steps?: number | null | undefined;
+    /**
+     * How strongly the generated images should reflect the original image supplied in imageDataUrl. Must be a float between 0.1 and 1.
+     */
+    strength?: number | null | undefined;
+    /**
+     * The style to generate LCM images with.
+     */
+    style?: shared.LcmGenerationStyle | undefined;
+    /**
+     * The output width of the image. Must be 512, 640 or 1024.
+     */
+    width?: number | null | undefined;
+};
+
+export type LcmGenerationOutput = {
+    /**
+     * API credits cost, available for Production API users.
+     */
+    apiCreditCost?: number | null | undefined;
+    imageDataUrl?: Array<string> | undefined;
+    requestTimestamp?: string | undefined;
+};
+
+/**
+ * Responses for POST /generations-lcm
+ */
+export type PostGenerationsLcmResponseBody = {
+    lcmGenerationJob?: LcmGenerationOutput | null | undefined;
+};
+
+export type PostGenerationsLcmResponse = {
+    /**
+     * HTTP response content type for this operation
+     */
+    contentType: string;
+    /**
+     * HTTP response status code for this operation
+     */
+    statusCode: number;
+    /**
+     * Raw HTTP response; suitable for custom response parsing
+     */
+    rawResponse: Response;
+    /**
+     * Responses for POST /generations-lcm
+     */
+    object?: PostGenerationsLcmResponseBody | undefined;
+};
+
+/** @internal */
+export namespace PostGenerationsLcmRequestBody$ {
+    export type Inbound = {
+        guidance?: number | null | undefined;
+        height?: number | null | undefined;
+        imageDataUrl: string;
+        prompt: string;
+        requestTimestamp?: string | undefined;
+        seed?: number | null | undefined;
+        steps?: number | null | undefined;
+        strength?: number | null | undefined;
+        style?: shared.LcmGenerationStyle | undefined;
+        width?: number | null | undefined;
+    };
+
+    export const inboundSchema: z.ZodType<PostGenerationsLcmRequestBody, z.ZodTypeDef, Inbound> = z
+        .object({
+            guidance: z.nullable(z.number()).optional(),
+            height: z.nullable(z.number().int().default(512)),
+            imageDataUrl: z.string(),
+            prompt: z.string(),
+            requestTimestamp: z.string().optional(),
+            seed: z.nullable(z.number().int()).optional(),
+            steps: z.nullable(z.number().int()).optional(),
+            strength: z.nullable(z.number()).optional(),
+            style: shared.LcmGenerationStyle$.optional(),
+            width: z.nullable(z.number().int().default(512)),
+        })
+        .transform((v) => {
+            return {
+                ...(v.guidance === undefined ? null : { guidance: v.guidance }),
+                height: v.height,
+                imageDataUrl: v.imageDataUrl,
+                prompt: v.prompt,
+                ...(v.requestTimestamp === undefined
+                    ? null
+                    : { requestTimestamp: v.requestTimestamp }),
+                ...(v.seed === undefined ? null : { seed: v.seed }),
+                ...(v.steps === undefined ? null : { steps: v.steps }),
+                ...(v.strength === undefined ? null : { strength: v.strength }),
+                ...(v.style === undefined ? null : { style: v.style }),
+                width: v.width,
+            };
+        });
+
+    export type Outbound = {
+        guidance?: number | null | undefined;
+        height: number | null;
+        imageDataUrl: string;
+        prompt: string;
+        requestTimestamp?: string | undefined;
+        seed?: number | null | undefined;
+        steps?: number | null | undefined;
+        strength?: number | null | undefined;
+        style?: shared.LcmGenerationStyle | undefined;
+        width: number | null;
+    };
+
+    export const outboundSchema: z.ZodType<Outbound, z.ZodTypeDef, PostGenerationsLcmRequestBody> =
+        z
+            .object({
+                guidance: z.nullable(z.number()).optional(),
+                height: z.nullable(z.number().int().default(512)),
+                imageDataUrl: z.string(),
+                prompt: z.string(),
+                requestTimestamp: z.string().optional(),
+                seed: z.nullable(z.number().int()).optional(),
+                steps: z.nullable(z.number().int()).optional(),
+                strength: z.nullable(z.number()).optional(),
+                style: shared.LcmGenerationStyle$.optional(),
+                width: z.nullable(z.number().int().default(512)),
+            })
+            .transform((v) => {
+                return {
+                    ...(v.guidance === undefined ? null : { guidance: v.guidance }),
+                    height: v.height,
+                    imageDataUrl: v.imageDataUrl,
+                    prompt: v.prompt,
+                    ...(v.requestTimestamp === undefined
+                        ? null
+                        : { requestTimestamp: v.requestTimestamp }),
+                    ...(v.seed === undefined ? null : { seed: v.seed }),
+                    ...(v.steps === undefined ? null : { steps: v.steps }),
+                    ...(v.strength === undefined ? null : { strength: v.strength }),
+                    ...(v.style === undefined ? null : { style: v.style }),
+                    width: v.width,
+                };
+            });
+}
+
+/** @internal */
+export namespace LcmGenerationOutput$ {
+    export type Inbound = {
+        apiCreditCost?: number | null | undefined;
+        imageDataUrl?: Array<string> | undefined;
+        requestTimestamp?: string | undefined;
+    };
+
+    export const inboundSchema: z.ZodType<LcmGenerationOutput, z.ZodTypeDef, Inbound> = z
+        .object({
+            apiCreditCost: z.nullable(z.number().int()).optional(),
+            imageDataUrl: z.array(z.string()).optional(),
+            requestTimestamp: z.string().optional(),
+        })
+        .transform((v) => {
+            return {
+                ...(v.apiCreditCost === undefined ? null : { apiCreditCost: v.apiCreditCost }),
+                ...(v.imageDataUrl === undefined ? null : { imageDataUrl: v.imageDataUrl }),
+                ...(v.requestTimestamp === undefined
+                    ? null
+                    : { requestTimestamp: v.requestTimestamp }),
+            };
+        });
+
+    export type Outbound = {
+        apiCreditCost?: number | null | undefined;
+        imageDataUrl?: Array<string> | undefined;
+        requestTimestamp?: string | undefined;
+    };
+
+    export const outboundSchema: z.ZodType<Outbound, z.ZodTypeDef, LcmGenerationOutput> = z
+        .object({
+            apiCreditCost: z.nullable(z.number().int()).optional(),
+            imageDataUrl: z.array(z.string()).optional(),
+            requestTimestamp: z.string().optional(),
+        })
+        .transform((v) => {
+            return {
+                ...(v.apiCreditCost === undefined ? null : { apiCreditCost: v.apiCreditCost }),
+                ...(v.imageDataUrl === undefined ? null : { imageDataUrl: v.imageDataUrl }),
+                ...(v.requestTimestamp === undefined
+                    ? null
+                    : { requestTimestamp: v.requestTimestamp }),
+            };
+        });
+}
+
+/** @internal */
+export namespace PostGenerationsLcmResponseBody$ {
+    export type Inbound = {
+        lcmGenerationJob?: LcmGenerationOutput$.Inbound | null | undefined;
+    };
+
+    export const inboundSchema: z.ZodType<PostGenerationsLcmResponseBody, z.ZodTypeDef, Inbound> = z
+        .object({
+            lcmGenerationJob: z
+                .nullable(z.lazy(() => LcmGenerationOutput$.inboundSchema))
+                .optional(),
+        })
+        .transform((v) => {
+            return {
+                ...(v.lcmGenerationJob === undefined
+                    ? null
+                    : { lcmGenerationJob: v.lcmGenerationJob }),
+            };
+        });
+
+    export type Outbound = {
+        lcmGenerationJob?: LcmGenerationOutput$.Outbound | null | undefined;
+    };
+
+    export const outboundSchema: z.ZodType<Outbound, z.ZodTypeDef, PostGenerationsLcmResponseBody> =
+        z
+            .object({
+                lcmGenerationJob: z
+                    .nullable(z.lazy(() => LcmGenerationOutput$.outboundSchema))
+                    .optional(),
+            })
+            .transform((v) => {
+                return {
+                    ...(v.lcmGenerationJob === undefined
+                        ? null
+                        : { lcmGenerationJob: v.lcmGenerationJob }),
+                };
+            });
+}
+
+/** @internal */
+export namespace PostGenerationsLcmResponse$ {
+    export type Inbound = {
+        ContentType: string;
+        StatusCode: number;
+        RawResponse: Response;
+        object?: PostGenerationsLcmResponseBody$.Inbound | undefined;
+    };
+
+    export const inboundSchema: z.ZodType<PostGenerationsLcmResponse, z.ZodTypeDef, Inbound> = z
+        .object({
+            ContentType: z.string(),
+            StatusCode: z.number().int(),
+            RawResponse: z.instanceof(Response),
+            object: z.lazy(() => PostGenerationsLcmResponseBody$.inboundSchema).optional(),
+        })
+        .transform((v) => {
+            return {
+                contentType: v.ContentType,
+                statusCode: v.StatusCode,
+                rawResponse: v.RawResponse,
+                ...(v.object === undefined ? null : { object: v.object }),
+            };
+        });
+
+    export type Outbound = {
+        ContentType: string;
+        StatusCode: number;
+        RawResponse: never;
+        object?: PostGenerationsLcmResponseBody$.Outbound | undefined;
+    };
+
+    export const outboundSchema: z.ZodType<Outbound, z.ZodTypeDef, PostGenerationsLcmResponse> = z
+        .object({
+            contentType: z.string(),
+            statusCode: z.number().int(),
+            rawResponse: z.instanceof(Response).transform(() => {
+                throw new Error("Response cannot be serialized");
+            }),
+            object: z.lazy(() => PostGenerationsLcmResponseBody$.outboundSchema).optional(),
+        })
+        .transform((v) => {
+            return {
+                ContentType: v.contentType,
+                StatusCode: v.statusCode,
+                RawResponse: v.rawResponse,
+                ...(v.object === undefined ? null : { object: v.object }),
+            };
+        });
+}