@leonardo-ai/sdk 4.21.1 → 4.21.2

package/src/lib/sdks.ts

@@ -124,13 +124,15 @@ export class ClientSDK {
     if (!base) {
       return ERR(new InvalidRequestError("No base URL provided for operation"));
     }
-    const reqURL = new URL(base);
-    const inputURL = new URL(path, reqURL);
-
+    const baseURL = new URL(base);
+    let reqURL: URL;
     if (path) {
-      reqURL.pathname += reqURL.pathname.endsWith("/") ? "" : "/";
-      reqURL.pathname += inputURL.pathname.replace(/^\/+/, "");
+      baseURL.pathname = baseURL.pathname.replace(/\/+$/, "") + "/";
+      reqURL = new URL(path, baseURL);
+    } else {
+      reqURL = baseURL;
     }
+    reqURL.hash = "";
 
     let finalQuery = query || "";
 

package/src/lib/security.ts

@@ -197,8 +197,7 @@ export function resolveSecurity(
         applyBearer(state, spec);
         break;
       default:
-        spec satisfies never;
-        throw SecurityError.unrecognizedType(type);
+        throw SecurityError.unrecognizedType((spec satisfies never, type));
     }
   });
 
@@ -240,8 +239,9 @@ function applyBearer(
 
 export function resolveGlobalSecurity(
   security: Partial<shared.Security> | null | undefined,
+  allowedFields?: number[],
 ): SecurityState | null {
-  return resolveSecurity(
+  let inputs: SecurityInput[][] = [
     [
       {
         fieldName: "Authorization",
@@ -249,7 +249,18 @@ export function resolveGlobalSecurity(
         value: security?.bearerAuth,
       },
     ],
-  );
+  ];
+
+  if (allowedFields) {
+    inputs = allowedFields.map((i) => {
+      if (i < 0 || i >= inputs.length) {
+        throw new RangeError(`invalid allowedFields index ${i}`);
+      }
+      return inputs[i]!;
+    });
+  }
+
+  return resolveSecurity(...inputs);
 }
 
 export async function extractSecurity<

package/src/lib/url.ts

@@ -13,21 +13,23 @@ export function pathToFunc(
   const paramRE = /\{([a-zA-Z0-9_][a-zA-Z0-9_-]*?)\}/g;
 
   return function buildURLPath(params: Record<string, unknown> = {}): string {
-    return pathPattern.replace(paramRE, function (_, placeholder) {
-      if (!hasOwn.call(params, placeholder)) {
-        throw new Error(`Parameter '${placeholder}' is required`);
-      }
+    return pathPattern
+      .replace(paramRE, function (_, placeholder) {
+        if (!hasOwn.call(params, placeholder)) {
+          throw new Error(`Parameter '${placeholder}' is required`);
+        }
 
-      const value = params[placeholder];
-      if (typeof value !== "string" && typeof value !== "number") {
-        throw new Error(
-          `Parameter '${placeholder}' must be a string or number`,
-        );
-      }
+        const value = params[placeholder];
+        if (typeof value !== "string" && typeof value !== "number") {
+          throw new Error(
+            `Parameter '${placeholder}' must be a string or number`,
+          );
+        }
 
-      return options?.charEncoding === "percent"
-        ? encodeURIComponent(`${value}`)
-        : `${value}`;
-    });
+        return options?.charEncoding === "percent"
+          ? encodeURIComponent(`${value}`)
+          : `${value}`;
+      })
+      .replace(/^\/+/, "");
   };
 }

package/src/sdk/media.ts

@@ -0,0 +1,63 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { mediaDeleteUploadedMediaById } from "../funcs/mediaDeleteUploadedMediaById.js";
+import { mediaGetUploadedMediaById } from "../funcs/mediaGetUploadedMediaById.js";
+import { mediaUploadMedia } from "../funcs/mediaUploadMedia.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "./models/operations/index.js";
+import { unwrapAsync } from "./types/fp.js";
+
+export class Media extends ClientSDK {
+  /**
+   * Delete uploaded media
+   *
+   * @remarks
+   * This endpoint deletes an uploaded media record and removes the associated file from S3
+   */
+  async deleteUploadedMediaById(
+    id: string,
+    options?: RequestOptions,
+  ): Promise<operations.DeleteUploadedMediaByIdResponse> {
+    return unwrapAsync(mediaDeleteUploadedMediaById(
+      this,
+      id,
+      options,
+    ));
+  }
+
+  /**
+   * Get uploaded media
+   *
+   * @remarks
+   * This endpoint returns details of an uploaded media record
+   */
+  async getUploadedMediaById(
+    id: string,
+    options?: RequestOptions,
+  ): Promise<operations.GetUploadedMediaByIdResponse> {
+    return unwrapAsync(mediaGetUploadedMediaById(
+      this,
+      id,
+      options,
+    ));
+  }
+
+  /**
+   * Upload media
+   *
+   * @remarks
+   * This endpoint returns presigned details to upload a media file to S3
+   */
+  async uploadMedia(
+    request: operations.UploadMediaRequestBody,
+    options?: RequestOptions,
+  ): Promise<operations.UploadMediaResponse> {
+    return unwrapAsync(mediaUploadMedia(
+      this,
+      request,
+      options,
+    ));
+  }
+}

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

@@ -0,0 +1,144 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type DeleteUploadedMediaByIdRequest = {
+  /**
+   * _"id" is required_
+   */
+  id: string;
+};
+
+export type UploadedMedia = {
+  id?: string | null | undefined;
+};
+
+/**
+ * Responses for DELETE /media/{id}
+ */
+export type DeleteUploadedMediaByIdResponseBody = {
+  deleteUploadedMediaByPk?: UploadedMedia | null | undefined;
+};
+
+export type DeleteUploadedMediaByIdResponse = {
+  /**
+   * 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 DELETE /media/{id}
+   */
+  object?: DeleteUploadedMediaByIdResponseBody | undefined;
+};
+
+/** @internal */
+export type DeleteUploadedMediaByIdRequest$Outbound = {
+  id: string;
+};
+
+/** @internal */
+export const DeleteUploadedMediaByIdRequest$outboundSchema: z.ZodType<
+  DeleteUploadedMediaByIdRequest$Outbound,
+  z.ZodTypeDef,
+  DeleteUploadedMediaByIdRequest
+> = z.object({
+  id: z.string(),
+});
+
+export function deleteUploadedMediaByIdRequestToJSON(
+  deleteUploadedMediaByIdRequest: DeleteUploadedMediaByIdRequest,
+): string {
+  return JSON.stringify(
+    DeleteUploadedMediaByIdRequest$outboundSchema.parse(
+      deleteUploadedMediaByIdRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const UploadedMedia$inboundSchema: z.ZodType<
+  UploadedMedia,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.nullable(z.string()).optional(),
+});
+
+export function uploadedMediaFromJSON(
+  jsonString: string,
+): SafeParseResult<UploadedMedia, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UploadedMedia$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UploadedMedia' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeleteUploadedMediaByIdResponseBody$inboundSchema: z.ZodType<
+  DeleteUploadedMediaByIdResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  delete_uploaded_media_by_pk: z.nullable(
+    z.lazy(() => UploadedMedia$inboundSchema),
+  ).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "delete_uploaded_media_by_pk": "deleteUploadedMediaByPk",
+  });
+});
+
+export function deleteUploadedMediaByIdResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteUploadedMediaByIdResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeleteUploadedMediaByIdResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteUploadedMediaByIdResponseBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeleteUploadedMediaByIdResponse$inboundSchema: z.ZodType<
+  DeleteUploadedMediaByIdResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  ContentType: z.string(),
+  StatusCode: z.number().int(),
+  RawResponse: z.instanceof(Response),
+  object: z.lazy(() => DeleteUploadedMediaByIdResponseBody$inboundSchema)
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "ContentType": "contentType",
+    "StatusCode": "statusCode",
+    "RawResponse": "rawResponse",
+  });
+});
+
+export function deleteUploadedMediaByIdResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteUploadedMediaByIdResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeleteUploadedMediaByIdResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteUploadedMediaByIdResponse' from JSON`,
+  );
+}

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

@@ -0,0 +1,167 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type GetUploadedMediaByIdRequest = {
+  /**
+   * _"id" is required_
+   */
+  id: string;
+};
+
+export type GetUploadedMediaByIdUploadedMedia = {
+  createdAt?: string | null | undefined;
+  duration?: number | null | undefined;
+  height?: number | null | undefined;
+  id?: string | null | undefined;
+  mediaType?: string | null | undefined;
+  status?: string | null | undefined;
+  statusReason?: string | null | undefined;
+  thumbnailUrl?: string | null | undefined;
+  url?: string | null | undefined;
+  videoFps?: number | null | undefined;
+  width?: number | null | undefined;
+};
+
+/**
+ * Responses for GET /media/{id}
+ */
+export type GetUploadedMediaByIdResponseBody = {
+  uploadedMediaByPk?: GetUploadedMediaByIdUploadedMedia | null | undefined;
+};
+
+export type GetUploadedMediaByIdResponse = {
+  /**
+   * 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 GET /media/{id}
+   */
+  object?: GetUploadedMediaByIdResponseBody | undefined;
+};
+
+/** @internal */
+export type GetUploadedMediaByIdRequest$Outbound = {
+  id: string;
+};
+
+/** @internal */
+export const GetUploadedMediaByIdRequest$outboundSchema: z.ZodType<
+  GetUploadedMediaByIdRequest$Outbound,
+  z.ZodTypeDef,
+  GetUploadedMediaByIdRequest
+> = z.object({
+  id: z.string(),
+});
+
+export function getUploadedMediaByIdRequestToJSON(
+  getUploadedMediaByIdRequest: GetUploadedMediaByIdRequest,
+): string {
+  return JSON.stringify(
+    GetUploadedMediaByIdRequest$outboundSchema.parse(
+      getUploadedMediaByIdRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const GetUploadedMediaByIdUploadedMedia$inboundSchema: z.ZodType<
+  GetUploadedMediaByIdUploadedMedia,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  createdAt: z.nullable(z.string()).optional(),
+  duration: z.nullable(z.number()).optional(),
+  height: z.nullable(z.number().int()).optional(),
+  id: z.nullable(z.string()).optional(),
+  mediaType: z.nullable(z.string()).optional(),
+  status: z.nullable(z.string()).optional(),
+  statusReason: z.nullable(z.string()).optional(),
+  thumbnailUrl: z.nullable(z.string()).optional(),
+  url: z.nullable(z.string()).optional(),
+  video_fps: z.nullable(z.number()).optional(),
+  width: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "video_fps": "videoFps",
+  });
+});
+
+export function getUploadedMediaByIdUploadedMediaFromJSON(
+  jsonString: string,
+): SafeParseResult<GetUploadedMediaByIdUploadedMedia, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetUploadedMediaByIdUploadedMedia$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetUploadedMediaByIdUploadedMedia' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetUploadedMediaByIdResponseBody$inboundSchema: z.ZodType<
+  GetUploadedMediaByIdResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  uploaded_media_by_pk: z.nullable(
+    z.lazy(() => GetUploadedMediaByIdUploadedMedia$inboundSchema),
+  ).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "uploaded_media_by_pk": "uploadedMediaByPk",
+  });
+});
+
+export function getUploadedMediaByIdResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<GetUploadedMediaByIdResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetUploadedMediaByIdResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetUploadedMediaByIdResponseBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetUploadedMediaByIdResponse$inboundSchema: z.ZodType<
+  GetUploadedMediaByIdResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  ContentType: z.string(),
+  StatusCode: z.number().int(),
+  RawResponse: z.instanceof(Response),
+  object: z.lazy(() => GetUploadedMediaByIdResponseBody$inboundSchema)
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "ContentType": "contentType",
+    "StatusCode": "statusCode",
+    "RawResponse": "rawResponse",
+  });
+});
+
+export function getUploadedMediaByIdResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetUploadedMediaByIdResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetUploadedMediaByIdResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetUploadedMediaByIdResponse' from JSON`,
+  );
+}

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

@@ -23,6 +23,7 @@ export * from "./deletegenerationbyid.js";
 export * from "./deleteinitimagebyid.js";
 export * from "./deletemodelbyid.js";
 export * from "./deletetexturegenerationbyid.js";
+export * from "./deleteuploadedmediabyid.js";
 export * from "./executeblueprint.js";
 export * from "./getblueprintbyid.js";
 export * from "./getblueprintexecution.js";
@@ -37,6 +38,7 @@ export * from "./getgenerationsbyuserid.js";
 export * from "./getinitimagebyid.js";
 export * from "./getmodelbyid.js";
 export * from "./getmotionvariationbyid.js";
+export * from "./getuploadedmediabyid.js";
 export * from "./getuserself.js";
 export * from "./getvariationbyid.js";
 export * from "./listelements.js";
@@ -51,4 +53,5 @@ export * from "./uploadcanvasinitimage.js";
 export * from "./uploaddatasetimage.js";
 export * from "./uploaddatasetimagefromgen.js";
 export * from "./uploadinitimage.js";
+export * from "./uploadmedia.js";
 export * from "./uploadmodelasset.js";

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

@@ -0,0 +1,142 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Query parameters provided in the request body as a JSON object
+ */
+export type UploadMediaRequestBody = {
+  /**
+   * The file extension of the media file to upload. Supported extensions: mp4, mov.
+   */
+  extension: string;
+};
+
+export type MediaUploadOutput = {
+  fields?: string | null | undefined;
+  uploadId?: string | null | undefined;
+  url?: string | null | undefined;
+};
+
+/**
+ * Responses for POST /media
+ */
+export type UploadMediaResponseBody = {
+  uploadMedia?: MediaUploadOutput | null | undefined;
+};
+
+export type UploadMediaResponse = {
+  /**
+   * 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 /media
+   */
+  object?: UploadMediaResponseBody | undefined;
+};
+
+/** @internal */
+export type UploadMediaRequestBody$Outbound = {
+  extension: string;
+};
+
+/** @internal */
+export const UploadMediaRequestBody$outboundSchema: z.ZodType<
+  UploadMediaRequestBody$Outbound,
+  z.ZodTypeDef,
+  UploadMediaRequestBody
+> = z.object({
+  extension: z.string(),
+});
+
+export function uploadMediaRequestBodyToJSON(
+  uploadMediaRequestBody: UploadMediaRequestBody,
+): string {
+  return JSON.stringify(
+    UploadMediaRequestBody$outboundSchema.parse(uploadMediaRequestBody),
+  );
+}
+
+/** @internal */
+export const MediaUploadOutput$inboundSchema: z.ZodType<
+  MediaUploadOutput,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  fields: z.nullable(z.string()).optional(),
+  uploadId: z.nullable(z.string()).optional(),
+  url: z.nullable(z.string()).optional(),
+});
+
+export function mediaUploadOutputFromJSON(
+  jsonString: string,
+): SafeParseResult<MediaUploadOutput, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MediaUploadOutput$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MediaUploadOutput' from JSON`,
+  );
+}
+
+/** @internal */
+export const UploadMediaResponseBody$inboundSchema: z.ZodType<
+  UploadMediaResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  uploadMedia: z.nullable(z.lazy(() => MediaUploadOutput$inboundSchema))
+    .optional(),
+});
+
+export function uploadMediaResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<UploadMediaResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UploadMediaResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UploadMediaResponseBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const UploadMediaResponse$inboundSchema: z.ZodType<
+  UploadMediaResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  ContentType: z.string(),
+  StatusCode: z.number().int(),
+  RawResponse: z.instanceof(Response),
+  object: z.lazy(() => UploadMediaResponseBody$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "ContentType": "contentType",
+    "StatusCode": "statusCode",
+    "RawResponse": "rawResponse",
+  });
+});
+
+export function uploadMediaResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<UploadMediaResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UploadMediaResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UploadMediaResponse' from JSON`,
+  );
+}

package/src/sdk/sdk.ts

@@ -8,6 +8,7 @@ import { Dataset } from "./dataset.js";
 import { Elements } from "./elements.js";
 import { Image } from "./image.js";
 import { InitImages } from "./initimages.js";
+import { Media } from "./media.js";
 import { Models } from "./models.js";
 import { Motion } from "./motion.js";
 import { PricingCalculator } from "./pricingcalculator.js";
@@ -64,6 +65,11 @@ export class Leonardo extends ClientSDK {
     return (this._user ??= new User(this._options));
   }
 
+  private _media?: Media;
+  get media(): Media {
+    return (this._media ??= new Media(this._options));
+  }
+
   private _models?: Models;
   get models(): Models {
     return (this._models ??= new Models(this._options));