Skip to main content
Version: 0.0.3

Published interfaces

Exact declarations from @kittl/[email protected]. These are the types shipped by npm, including supporting declarations referenced by public APIs. A supporting declaration is not necessarily an exported runtime value.

API member inventory · Download the published declaration

AIGenerationInputSettings​

export interface AIGenerationInputSettings {
	prompt: string;
	taskType?: AIGenerationModelTaskType;
	promptStyleId?: number;
	model: {
		id: string;
	};
	additionalParams?: Record<string, unknown>;
	actionOrigin?: AIGenerationActionOrigin;
	type: AIGenerationContentType;
}

AIGenerationOutputSettings​

export interface AIGenerationOutputSettings {
	id?: string;
	dimensions: {
		width: number;
		height: number;
	};
}

AppStateAPI​

export interface AppStateAPI {
	getSelectedObjectsIds(): string[];
	setSelectedObjectsIds(ids: string[]): void;
	getSelectedLayersIds(): string[];
	setSelectedLayersIds(ids: string[]): void;
	getSelectedArtboardIds(): string[];
	setSelectedArtboardIds(ids: string[]): void;
	getSelectedArtboardsObjectIds(): string[];
	setSelectedArtboardsObjectIds(ids: string[]): void;
	getAllSelectedObjectsIds(): string[];
	setAllSelectedObjectsIds(ids: string[]): void;
	getCanvasMode(): AppState["canvasMode"];
	setCanvasMode(mode: AppState["canvasMode"], origin?: Origin): void;
	getActiveTool(): ActiveTool | null;
	setActiveTool(tool: ActiveTool | null): void;
	viewport: ViewportAPI;
	getHighlightedObjectId(): string | null;
	setHighlightedObjectId(id: string | null): void;
	setMany(fields: Partial<AppState>, origin?: Origin): void;
}

AsyncAIAPI​

export interface AsyncAIAPI {
	spendCredits: (options: SpendCreditsOptions) => SdkResultAsync<SpendCreditsResult, Error>;
	startGeneration: (generatorId: string, inputSettings: AIGenerationInputSettings, output: AIGenerationOutputSettings) => SdkResultAsync<StartGenerationResult, Error>;
	registerHandler: (generatorId: string, onStatusUpdate: OnGenerationStatusUpdate) => SdkResultAsync<() => void, Error>;
}

AsyncAppStateAPI​

export interface AsyncAppStateAPI extends WithAsync<AppStateAPI> {
}

AsyncAppStateSubscriptionAPI​

export interface AsyncAppStateSubscriptionAPI {
	/**
	 * Subscribe to one or more paths in the app state.
	 * Each path is a dot-separated string like `'selectedObjectsIds'`.
	 * The callback receives the current value at each path as positional
	 * arguments whenever any subscribed value changes.
	 * Returns a single unsubscribe function that tears down all subscriptions.
	 *
	 * @example
	 * // Single path
	 * const unsub = await kittl.appStore.subscribe(
	 *   ['selectedObjectsIds'],
	 *   (ids) => console.log('selection changed:', ids)
	 * );
	 *
	 * // Multiple paths
	 * const unsub = await kittl.appStore.subscribe(
	 *   ['selectedObjectsIds', 'activeTool'],
	 *   (ids, tool) => console.log('changed:', ids, tool)
	 * );
	 * unsub();
	 */
	subscribe<T extends readonly AppStateSelectorPath[]>(paths: [
		...T
	], callback: (...values: {
		[K in keyof T]: T[K] extends string ? DeepValue<AppState, T[K]> | undefined : unknown;
	}) => void): Promise<() => void>;
}

AsyncAuthAPI​

export interface AsyncAuthAPI {
	startAuth: (request: AuthStartRequest) => Promise<SdkResult<AuthStartResult>>;
	exchangeCode: (request: AuthExchangeRequest) => Promise<SdkResult<AuthTokenResponse>>;
	getAuthToken: (request: AuthGetTokenRequest) => Promise<SdkResult<AuthTokenResponse | null>>;
	refreshToken: (request: AuthRefreshRequest) => Promise<SdkResult<AuthTokenResponse>>;
	logout: (request: AuthLogoutRequest) => Promise<SdkResult<void>>;
}

AsyncBatchDesignAPI​

export interface AsyncBatchDesignAPI extends AsyncDesignAPI {
	commit: () => Promise<void>;
}

AsyncContextAPI​

export interface AsyncContextAPI extends WithAsync<ContextAPI> {
}

AsyncDesignAPI​

export interface AsyncDesignAPI extends WithAsync<WithOptsRemoved<DesignAPI>> {
}

AsyncDesignStateAPI​

export interface AsyncDesignStateAPI {
	/**
	 * Subscribe to one or more paths in the design state.
	 * Each path is a dot-separated string like `'objects.id1.width'`.
	 * The callback receives the current value at each path as positional
	 * arguments whenever any subscribed value changes.
	 * Returns a single unsubscribe function that tears down all subscriptions.
	 *
	 * @example
	 * // Single path
	 * const unsub = await kittl.designStore.subscribe(
	 *   ['objects.id1.width'],
	 *   (width) => console.log('width changed:', width)
	 * );
	 *
	 * // Multiple paths
	 * const unsub = await kittl.designStore.subscribe(
	 *   ['objects.id1.width', 'objects.id1.height'],
	 *   (width, height) => console.log('changed:', width, height)
	 * );
	 * unsub();
	 */
	subscribe<T extends readonly DesignStateSelectorPath[]>(paths: [
		...T
	], callback: (...values: {
		[K in keyof T]: T[K] extends string ? DeepValue<SelectorState, T[K]> | undefined : unknown;
	}) => void): Promise<() => void>;
}

AsyncFontAPI​

export interface AsyncFontAPI extends WithAsync<FontAPI> {
}

AsyncStatelessAPI​

export interface AsyncStatelessAPI {
	send: (message: {
		type: string;
		payload: Record<string, unknown>;
	}) => SdkResultAsync<null>;
	subscribe: (key: string, handler: (payload: Record<string, unknown>) => void) => SdkResultAsync<null>;
	unsubscribe: (key: string) => SdkResultAsync<null>;
}

AsyncUploadAPI​

export interface AsyncUploadAPI extends WithAsync<UploadAPI> {
}

AuthExchangeRequest​

export interface AuthExchangeRequest {
	code: string;
	code_verifier?: string;
	provider: string;
	params?: Record<string, unknown>;
	headers?: Record<string, string>;
}

AuthGetTokenRequest​

export interface AuthGetTokenRequest {
	provider: string;
}

AuthLogoutRequest​

export interface AuthLogoutRequest {
	provider?: string;
}

AuthRefreshRequest​

export interface AuthRefreshRequest {
	provider: string;
	refresh_token: string;
}

AuthStartRequest​

export interface AuthStartRequest {
	provider: string;
	params?: Record<string, string | number | boolean>;
	generatePKCE?: boolean;
}

AuthStartResult​

export interface AuthStartResult {
	code: string;
	code_verifier?: string;
}

AuthTokenResponse​

/**
 * Token response returned by the token endpoint (code exchange or refresh).
 */
export interface AuthTokenResponse {
	access_token?: string;
	refresh_token?: string;
	expires_in?: number;
	[key: string]: unknown;
}

BackgroundImageOptions​

export interface BackgroundImageOptions extends GeneratableObject {
	objectName?: string;
	globalCompositeOperation: BlendMode;
	opacity: number;
	filters?: SerialisedPhotoFilter[];
	hidden?: boolean;
	cropX?: number;
	cropY?: number;
	scaleX?: number;
	scaleY?: number;
	width?: number;
	height?: number;
	realWidth?: number;
	realHeight?: number;
}

BaseStandardArtboardOptions​

export interface BaseStandardArtboardOptions<T extends ArtboardLikeType = ArtboardLikeType> {
	type?: T;
	rx?: number | undefined;
	ry?: number | undefined;
	id?: string;
	lockMovementX?: boolean;
	lockMovementY?: boolean;
	activeLayout: BoardLayout;
	left?: number;
	top?: number;
	width: number;
	height: number;
	fill: string | GradientObject | undefined | null;
	opacity?: number;
	hidden?: boolean;
	unit?: Unit;
	dpi?: number;
	fullSize?: boolean;
	clip?: boolean;
	presets?: LinkedPreset[];
	printMargins?: PrintMargins;
	scaleX?: number;
	scaleY?: number;
}

BaseStandardBoard​

export interface BaseStandardBoard<T extends ArtboardOptions = ArtboardOptions> {
	id: string;
	artboard: T;
	title?: string;
	texture?: TextureOptions;
	backgroundImage?: BackgroundImageOptions;
}

BoardAPI​

export interface BoardAPI {
	createStandardBoard(params: CreateBoardParams, opts?: DesignApiOptions): NormalizedBoard;
	cloneArtboard(params: CloneArtboardParams, opts?: DesignApiOptions): NormalizedBoard;
	updateArtboardBackground(params: UpdateArtboardBackgroundParams, opts?: DesignApiOptions): NormalizedBoard;
	updateArtboard(params: UpdateArtboardParams, opts?: DesignApiOptions): NormalizedBoard;
}

CanvasAPI​

export interface CanvasAPI {
	getScreenshot(): Promise<{
		data: string;
		width: number;
		height: number;
	}>;
	getPreviewImage: (id: string, options?: Partial<GetPreviewImageOptions>) => Promise<string | null>;
	getExport: (options: GetExportOptions) => Promise<Blob | null>;
}

ConfigAPI​

export interface ConfigAPI {
	setConfig(config: Partial<DesignConfig>, opts?: DesignApiOptions): void;
}

ContextAPI​

export interface ContextAPI {
	get(input?: ContextGetInput): KittlContext;
}

ContextGetInput​

export interface ContextGetInput {
	iframe?: Pick<HTMLIFrameElement, "getBoundingClientRect">;
}

CreateLoadingCardInput​

export interface CreateLoadingCardInput extends CreateElementWithPositionAndSize {
	imageGenerationId?: string;
	startedAt?: number;
	generatingModelKey?: string;
	generationAverageSpeed?: number;
	name?: string;
}

DecorationOptions​

export interface DecorationOptions {
	type: "horizontalLines" | "colorCut" | "obliqueLines" | "fadingColorCut";
	color: string | null;
	weight: number;
	distance: number;
	cutDistance: number;
}

DesignAPI​

export interface DesignAPI {
	shape: ShapeAPI;
	board: BoardAPI;
	config: ConfigAPI;
	text: TextAPI;
	object: ObjectAPI;
	guide: GuideAPI;
	loadingCard: LoadingCardAPI;
	image: ImageAPI;
	illustration: IllustrationAPI;
	state: StateAPI;
	canvas: CanvasAPI;
	mockupboard: MockupboardAPI;
	smartboard: SmartboardAPI;
	video: VideoAPI;
	videoboard: VideoboardAPI;
	layers: LayersAPI;
	group: GroupAPI;
	texture: TextureAPI;
}

DesignConfig​

export interface DesignConfig {
	title?: string;
	dpiVersion?: number;
	designId?: string;
	generationId?: string;
	updatedAt?: string;
	templateId?: number | string;
	folderId?: string;
	dpi?: number;
	unit?: Unit;
	overrideColorPalette?: string[];
	overrideColorKeys?: string[];
	overrideLuminosityRatio?: number;
	previewBoardId?: string;
}

DragAndDropDropImageInput​

export interface DragAndDropDropImageInput {
	x: number;
	y: number;
	grabOffsetX?: number;
	grabOffsetY?: number;
	src: string;
	imgWidth?: number;
	imgHeight?: number;
	persistImage?: boolean;
}

DragAndDropOffset​

export interface DragAndDropOffset {
	left: number;
	top: number;
}

DragAndDropStartDragImageEventInput​

export interface DragAndDropStartDragImageEventInput {
	event: DragEvent;
	img: HTMLImageElement;
	persistImage?: boolean;
}

ErrorGenerationResult​

export interface ErrorGenerationResult {
	type: typeof ResultType.ERROR;
	message: string;
	code?: string;
}

FontAPI​

export interface FontAPI {
	createFont: (params: {
		name: string;
		files: Blob[];
		styles: string[];
		extensionId?: string;
		previewImage?: Blob;
	}) => SdkResultAsync<UploadedFontFamily, Error>;
}

FontVariation​

export interface FontVariation {
	name: string;
	min: number;
	max: number;
	default: number;
}

GeneratableBoard​

export interface GeneratableBoard<T extends Record<string, unknown> = never> {
	generationSettings?: T;
}

GeneratableObject​

export interface GeneratableObject {
	generation?: {
		meta?: GenerationMeta;
		generationId?: string;
		generatorKey: string;
	};
}

GenerationInputData​

export interface GenerationInputData {
	prompt?: string;
	style?: {
		id: number;
	};
	model?: {
		id: string;
	};
}

GenerationMeta​

export interface GenerationMeta {
	generationEndsAt?: number;
	pendingGenerationId: string;
}

GenerationStartedResultCommonProps​

export interface GenerationStartedResultCommonProps {
	generationEndsAt?: number;
}

GetExportOptions​

export interface GetExportOptions {
	format: "png" | "jpg" | "pdf" | "svg" | "mp4";
	target: {
		boardId: string;
	} | {
		nodeIds: string[];
	};
	dimensions?: {
		multiplier: number;
	} | {
		pixelCount: number;
	} | {
		target: {
			width: number;
			height: number;
		};
	};
	removeArtboardBackground?: boolean;
}

GetObjectParams​

export interface GetObjectParams {
	id: string;
}

GetPreviewImageOptions​

export interface GetPreviewImageOptions {
	targetPixelCount: number;
}

GradientColorStop​

export interface GradientColorStop {
	color: string | null;
	offset: number;
	opacity?: number;
}

GradientInfo​

export interface GradientInfo {
	count: number;
	angle: number;
	offsets: number[];
	gradientTransform?: number[];
	coords?: {
		x1: number;
		x2: number;
		y1: number;
		y2: number;
		r1?: number;
		r2?: number;
	};
	type: GradientType;
}

GradientObject​

export interface GradientObject {
	id?: string;
	key?: string;
	colorStops: GradientColorStop[];
	coords?: {
		x1: number;
		x2: number;
		y1: number;
		y2: number;
		r1?: number;
		r2?: number;
	};
	type: GradientType;
	angle?: number;
	gradientTransform?: number[];
}

GroupAPI​

export interface GroupAPI {
	createGroup(input: CreateGroupParams, opts?: DesignApiOptions): void;
	removeGroup(input: RemoveGroupParams, opts?: DesignApiOptions): void;
	addIntoGroup(input: AddIntoGroupParams, opts?: DesignApiOptions): void;
	removeFromGroup(input: RemoveFromGroupParams, opts?: DesignApiOptions): void;
}

GuideAPI​

export interface GuideAPI {
	createGuide(input: CreateGuideInput, opts?: DesignApiOptions): NormalizedGuideObject;
	updateGuide(input: UpdateGuideInput, opts?: DesignApiOptions): NormalizedGuideObject;
}

IllustrationAPI​

export interface IllustrationAPI {
	addIllustration(params: AddIllustrationParams, opts?: DesignApiOptions): Promise<NormalizedIllustrationObject>;
	updateIllustration(params: UpdateIllustrationParams, opts?: DesignApiOptions): NormalizedIllustrationObject;
}

ImageAPI​

export interface ImageAPI {
	addImage(params: AddImageParams, opts?: DesignApiOptions): SdkResultAsync<NormalizedIllustrationImageObject, SdkError>;
	updateImage(params: UpdateImageParams, opts?: DesignApiOptions): NormalizedIllustrationImageObject;
}

ImageGenerationResult​

export interface ImageGenerationResult {
	type: typeof ResultType.IMAGE;
	objectName: string;
}

ImageGenerationStartedResult​

export interface ImageGenerationStartedResult extends GenerationStartedResultCommonProps {
	type: typeof ResultType.IMAGE;
}

KittlContext​

export interface KittlContext {
	colorScheme: EditorColorScheme;
	dragAndDrop: {
		offset: DragAndDropOffset;
	};
}

KittlSDK​

export interface KittlSDK {
	loaded: boolean;
	onLoadedCallback: (() => void) | null;
	onReady: (cb: () => void) => void;
	ai: AsyncAIAPI;
	design: AsyncDesignAPI;
	designStore: AsyncDesignStateAPI;
	appStore: AsyncAppStateSubscriptionAPI;
	context: AsyncContextAPI;
	dragAndDrop: PublicDragAndDropAPI;
	state: AsyncAppStateAPI;
	auth: AsyncAuthAPI;
	upload: AsyncUploadAPI;
	stateless: AsyncStatelessAPI;
	font: AsyncFontAPI;
	createBatch: () => Promise<AsyncBatchDesignAPI>;
}

LayersAPI​

export interface LayersAPI {
	moveTo(input: MoveToParams, opts?: DesignApiOptions): void;
	sendForward(input: SendToParams, opts?: DesignApiOptions): void;
	sendToFront(input: SendToParams, opts?: DesignApiOptions): void;
	sendBackward(input: SendToParams, opts?: DesignApiOptions): void;
	sendToBack(input: SendToParams, opts?: DesignApiOptions): void;
}

LinkedFillPresetMeta​

export interface LinkedFillPresetMeta {
	key: string;
	target: FillMetaTarget;
	source?: string;
}

LoadingCardAPI​

export interface LoadingCardAPI {
	createLoadingCard(input: CreateLoadingCardInput, opts?: DesignApiOptions): NormalizedLoadingCardObject;
	updateLoadingCard(input: UpdateLoadingCardInput, opts?: DesignApiOptions): NormalizedLoadingCardObject;
}

MockupboardAPI​

export interface MockupboardAPI {
	addMockupBoard(params: AddMockupBoardParams, opts?: DesignApiOptions): NormalizedStandardBoard<MockupBoardOptions>;
	addMockupDesignObject(params: AddMockupDesignObjectParams, opts?: DesignApiOptions): NormalizedMockupDesignObject;
	updateMockupBoard(params: UpdateMockupBoardParams, opts?: DesignApiOptions): NormalizedStandardBoard<MockupBoardOptions>;
}

ObjectAPI​

export interface ObjectAPI {
	setLockedState(params: SetLockedParams, opts?: DesignApiOptions): WithLocked;
	removeObject(params: RemoveObjectParams, opts?: DesignApiOptions): RemoveObjectResult;
	setHiddenState(params: SetHiddenParams, opts?: DesignApiOptions): WithHidden;
	rotateObject(params: RotateObjectParams, opts?: DesignApiOptions): WithObjectLayout;
	getAllByFilter<T extends NormalizedObject>(predicate: (object: NormalizedObject) => boolean, opts?: DesignApiOptions): T[];
	rename(input: RenameParams, opts?: DesignApiOptions): string;
	getObject(params: GetObjectParams, opts?: DesignApiOptions): NormalizedObject;
	_dangerouslyUpdate(updateParams: Partial<Omit<SerializedObject, "id">> & {
		id: string;
	}, opts?: DesignApiOptions): {
		id: string;
	};
}

PhotoFilterOptions​

export interface PhotoFilterOptions {
	[ImageFilterType.Saturation]: {
		saturation: number;
	};
	[ImageFilterType.Contrast]: {
		contrast: number;
	};
	[ImageFilterType.Brightness]: {
		brightness: number;
	};
	[ImageFilterType.Vibrance]: {
		vibrance: number;
	};
	[ImageFilterType.HueRotation]: {
		rotation: number;
	};
	[ImageFilterType.Noise]: {
		noise: number;
	};
	[ImageFilterType.Blur]: {
		blur: number;
	};
	[ImageFilterType.Convolute]: {
		matrix: number[];
	};
	[ImageFilterType.Pixelate]: {
		blocksize: number;
	};
	[ImageFilterType.RemoveColor]: {
		color: string | null;
		distance: number;
	};
}

PublicDragAndDropAPI​

export interface PublicDragAndDropAPI {
	startDragImageEvent(input: DragAndDropStartDragImageEventInput): void;
	dropImage(input: DragAndDropDropImageInput): Promise<string | null>;
}

RemoveObjectParams​

export interface RemoveObjectParams {
	id: string;
}

RemoveObjectResult​

export interface RemoveObjectResult {
	removedObject: NormalizedObject;
}

RichTextCompressedStylesV1​

export interface RichTextCompressedStylesV1 {
	version: "v1";
	[lineIndex: LineIndex]: {
		charsAt: CharacterIndex[];
		styles: Partial<RichTextSerializedCharacterStyle>;
	}[];
}

RichTextCompressedStylesV2​

export interface RichTextCompressedStylesV2 {
	version: "v2";
	customStyles: Record<string, Partial<RichTextSerializedCharacterStyle>>;
	[lineIndex: LineIndex]: {
		charsAt: [
			CharacterIndex,
			SequenceLength
		][];
		styleId: string;
	}[];
}

RotateObjectParams​

export interface RotateObjectParams {
	id: string;
	angle: number;
	origin?: {
		x: OriginX;
		y: OriginY;
	};
}

SdkBadInputError​

export interface SdkBadInputError extends Error {
	name: "SdkBadInputError";
	message: string;
	cause?: Error;
}

SdkInternalError​

export interface SdkInternalError extends Error {
	name: "SdkInternalError";
	message: string;
	cause?: Error;
}

SetHiddenParams​

export interface SetHiddenParams {
	id: string;
	hidden: boolean;
}

SetLockedParams​

export interface SetLockedParams {
	id: string;
	locked: boolean;
}

ShadowOptions​

export interface ShadowOptions {
	angle: number;
	offset: number;
	blur: number;
	color: string | null;
}

ShapeAPI​

export interface ShapeAPI {
	createPredefinedShape(input: CreateShapeInput, opts?: DesignApiOptions): NormalizedBasicShapeObject;
	createBasicShape(input: CreateBasicShapeInput, opts?: DesignApiOptions): Promise<NormalizedBasicShapeObject>;
	updateShape(input: UpdateShapeInput, opts?: DesignApiOptions): NormalizedBasicShapeObject;
	convertShapeToMask(input: ConvertShapeToMaskInput, opts?: DesignApiOptions): DesignStructureObject;
}

SmartboardAPI​

export interface SmartboardAPI {
	addSmartboard(params: AddSmartboardParams, opts?: DesignApiOptions): NormalizedStandardBoard<SmartboardOptions>;
	updateSmartboard(params: UpdateSmartboardParams, opts?: DesignApiOptions): NormalizedStandardBoard<SmartboardOptions>;
}

SpendCreditsOptions​

export interface SpendCreditsOptions {
	amount: number;
	message: string;
	onAccept?: () => void;
	onDecline?: () => void;
}

SpendCreditsResult​

export interface SpendCreditsResult {
	success: boolean;
}

StandardArtboardOptions​

export interface StandardArtboardOptions extends BaseStandardArtboardOptions<ObjectType.Artboard> {
}

StartGenerationResult​

export interface StartGenerationResult {
	generationId: string;
}

StateAPI​

export interface StateAPI {
	implementSubState(params: Partial<NormalizedDesignState>, opts?: DesignApiOptions): Partial<NormalizedDesignState>;
	getState(): NormalizedDesignState;
}

StructureObjectMeta​

export interface StructureObjectMeta {
	name?: string;
	type?: LayerType;
	defaultIcon?: LayerIconType;
	hidden?: boolean;
	locked?: boolean;
	open?: boolean;
	linkedBoardId?: string;
	maskObjectId?: string;
	maskBackgroundColor?: string | null;
}

TextAPI​

export interface TextAPI {
	addText(params: AddTextParams, opts?: DesignApiOptions): NormalizedRichTextObject;
	updateText(params: UpdateTextParams, opts?: DesignApiOptions): NormalizedRichTextObject;
	updateRenderPlugin(params: UpdateRenderPluginParams, opts?: DesignApiOptions): NormalizedRichTextObject;
	updateDecorationPlugin(params: UpdateDecorationPluginParams, opts?: DesignApiOptions): NormalizedRichTextObject;
}

TextureAPI​

export interface TextureAPI {
	setTexture(params: SetTextureParams, opts?: DesignApiOptions): SdkResult<NormalizedBoard, SdkError>;
	removeTexture(params: RemoveTextureParams, opts?: DesignApiOptions): SdkResult<NormalizedBoard, SdkError>;
	updateTexture(params: UpdateTextureParams, opts?: DesignApiOptions): SdkResult<NormalizedBoard, SdkError>;
	releaseTexture(params: ReleaseTextureParams, opts?: DesignApiOptions): SdkResult<IllustrationImageSerializedObject, SdkError>;
}

TextureOptions​

export interface TextureOptions {
	texture: string;
	mode: BlendMode;
	opacity: number;
	hidden?: boolean;
	loaded?: boolean;
	isAlphaMask?: boolean;
	renderClip?: boolean;
}

TransformOptions​

export interface TransformOptions {
	type: "freeLine" | "freeForm" | "circle" | "angle" | "arch" | "rise" | "wave" | "flag" | null;
	directionInverted?: boolean;
	curve?: number;
	isChanging?: boolean;
}

UpdateGuideInput​

export interface UpdateGuideInput {
	id: string;
	top?: number;
	left?: number;
}

UpdateLoadingCardInput​

export interface UpdateLoadingCardInput {
	id: string;
	position?: CreateElementWithPositionAndSize["position"];
	size?: CreateElementWithPositionAndSize["size"];
	imageGenerationId?: string;
	startedAt?: number;
	generatingModelKey?: string;
	generationAverageSpeed?: number;
	name?: string;
}

UploadAPI​

export interface UploadAPI {
	image: UploadImageAPI;
}

UploadImageAPI​

export interface UploadImageAPI {
	upload: ({ blob, extensionId, }: {
		blob: Blob;
		extensionId?: string;
	}) => SdkResultAsync<UserImageUpload[], Error>;
	uploadTemp: ({ blob, }: {
		blob: Blob;
	}) => SdkResultAsync<TempUserImageUpload[], Error>;
}

VideoAPI​

export interface VideoAPI {
	addVideo(params: AddVideoParams, opts?: DesignApiOptions): Promise<NormalizedVideoObject>;
	updateVideo(params: UpdateVideoParams, opts?: DesignApiOptions): NormalizedVideoObject;
	removePlaylistItem(params: RemoveVideoPlaylistItemParams, opts?: DesignApiOptions): NormalizedVideoObject;
	updatePlaylistItem(params: UpdateVideoPlaylistItemParams, opts?: DesignApiOptions): Promise<NormalizedVideoObject>;
}

VideoGenerationResult​

export interface VideoGenerationResult {
	type: typeof ResultType.VIDEO;
	status: "PROCESSING" | "READY" | "FAILED";
	playbackId?: string;
	duration?: number;
	aspectRatio?: string;
	hostingProvider?: "MUX";
}

VideoGenerationStartedResult​

export interface VideoGenerationStartedResult extends GenerationStartedResultCommonProps {
	type: typeof ResultType.VIDEO;
}

VideoboardAPI​

export interface VideoboardAPI {
	addVideoboard(params: AddVideoboardParams, opts?: DesignApiOptions): Promise<NormalizedStandardBoard<VideoboardOptions>>;
	setVideoOnVideoboard(params: SetVideoOnVideoboardParams, opts?: DesignApiOptions): Promise<NormalizedStandardBoard<VideoboardOptions>>;
	updateVideoboard(params: UpdateVideoboardParams, opts?: DesignApiOptions): NormalizedStandardBoard<VideoboardOptions>;
	removePlaylistItem(params: RemovePlaylistItemParams, opts?: DesignApiOptions): NormalizedStandardBoard<VideoboardOptions>;
	updatePlaylistItem(params: UpdatePlaylistItemParams, opts?: DesignApiOptions): Promise<NormalizedStandardBoard<VideoboardOptions>>;
}

WithHidden​

export interface WithHidden {
	hidden?: boolean | undefined;
}

WithLocked​

export interface WithLocked {
	locked?: boolean | undefined;
}

WithObjectLayout​

export interface WithObjectLayout {
	width: number;
	height: number;
	scaleX: number;
	scaleY: number;
	angle: number;
	top: number;
	left: number;
	flipX: boolean;
	flipY: boolean;
}