Skip to main content
Version: 0.0.9

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;
	referenceImageMode?: AIGenerationReferenceImageMode;
}

AIGenerationOutputSettings​

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

AddFontStyleOptions​

export interface AddFontStyleOptions {
	fontFamilyId: string;
	files: Blob[];
	styles: string[];
}

AppStateAPI​

export interface AppStateAPI {
	getSelectedObjectsIds(): string[];
	setSelectedObjectsIds(ids: string[], origin?: Origin): 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(): CanvasModeKind | string;
	getCanvasModeTargetId(): string | null;
	setCanvasMode(mode: CanvasModeKind | string, origin?: Origin): void;
	setCanvasModeWithTarget(mode: CanvasModeKind, options?: SetCanvasModeWithTargetOptions): void;
	setCustomCanvasMode<const Id extends string>(params: SetCustomCanvasModeParams<Id>, origin?: Origin): void;
	getActiveTool(): ActiveTool;
	setActiveTool(tool: ActiveTool, origin?: Origin): void;
	getIsDragPanning(): boolean;
	viewport: ViewportAPI;
	getHighlightedObjectId(): string | null;
	setHighlightedObjectId(id: string | null): void;
	setMany(fields: Partial<AppStateWithoutModes>, origin?: Origin): void;
	getIsViewOnlyMode(): boolean;
	setIsViewOnlyMode(isViewOnlyMode: boolean): void;
	setCanvasSettings: (settings: Partial<SettingsType>) => void;
	getCanvasSettings(): SettingsType;
	getPenToolSetting(): AppState["penToolSetting"];
	setPenToolSetting(setting: Partial<AppState["penToolSetting"]>): void;
	getOutlineLoading(): AppState["outlineLoading"];
	setOutlineLoading(id: string, loading: boolean): void;
	isObjectLoading(id: string): boolean;
	getPendingOperations(): AppState["pendingOperations"];
	isOperationPending(id: string, operation?: PendingOperation): boolean;
	setPendingOperation(id: string, operation: PendingOperation, origin?: Origin): void;
	clearPendingOperation(id: string, operation: PendingOperation, 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>;
	unregisterHandler: (generatorId: string) => SdkResultAsync<void, Error>;
}

AsyncAppStateAPI​

export interface AsyncAppStateAPI extends WithAsync<AppStateAPI> {
	setCustomCanvasMode<const Id extends string>(params: SetCustomCanvasModeParams<Id>, origin?: Origin): Promise<BridgedSdkResult<void>>;
}

AsyncAppStateSubscriptionAPI​

export interface AsyncAppStateSubscriptionAPI {
	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>>;
	getUserToken: () => Promise<SdkResult<UserTokenResult>>;
	logout: (request: AuthLogoutRequest) => Promise<SdkResult<void>>;
}

AsyncBatchDesignAPI​

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

AsyncContextAPI​

export interface AsyncContextAPI extends Omit<WithAsync<ContextAPI>, "subscribe"> {
	subscribe(callback: ContextSubscriptionCallback): Promise<() => void>;
}

AsyncDataAPI​

export interface AsyncDataAPI extends WithAsync<DataAPI> {
}

AsyncDesignAPI​

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

AsyncDesignStateAPI​

export interface AsyncDesignStateAPI {
	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>;
}

AsyncExportAPI​

export interface AsyncExportAPI extends Omit<WithAsync<ExportAPI>, "showExportModal"> {
	showExportModal<Mime extends ExportMimeType>(request: ExportRequest<Mime>): Promise<BridgedSdkResult<ExportResult>>;
}

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;
}

AuthStartRequest​

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

AuthStartResult​

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

AuthTokenResponse​

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;
	printMargins?: PrintMargins;
	scaleX?: number;
	scaleY?: number;
}

BaseStandardBoard​

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

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;
	connectBoards(params: ConnectBoardsParams, opts?: DesignApiOptions): void;
	disconnectBoards(params: DisconnectBoardsParams, opts?: DesignApiOptions): void;
}

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>;
}

CatalogItem​

export interface CatalogItem {
	id: string;
	name: string;
	previewImages: string[];
}

ConfigAPI​

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

ContextAPI​

export interface ContextAPI {
	get(input?: ContextGetInput): KittlContext;
	subscribe(callback: ContextSubscriptionCallback): () => void;
}

ContextGetInput​

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

CreateFontOptions​

export interface CreateFontOptions {
	name: string;
	files: Blob[];
	styles: string[];
	previewImage?: Blob;
}

CreateLoadingCardInput​

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

CustomCanvasModeStateById​

export interface CustomCanvasModeStateById {
}

DataAPI​

export interface DataAPI {
	mockups: MockupDataAPI;
	fonts: FontDataAPI;
}

DecorationOptions​

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

DeleteFontStyleOptions​

export interface DeleteFontStyleOptions {
	fontFamilyId: string;
	id: string;
}

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;
	placement: PlacementAPI;
}

DesignConfig​

export interface DesignConfig {
	microEditor?: {
		mainObjectId?: DesignObjectId;
		layerized?: boolean;
	};
	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;
	subtitle: string;
	status: "warning" | "error";
	isRecognized?: boolean;
	errorKey?: string;
}

FileBrowserAPI​

export interface FileBrowserAPI {
	registerUploadBrowser: (tab: Omit<FileBrowserTab, "onEvent">) => Promise<SdkResponse<void>>;
}

FontAPI​

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

FontDataAPI​

export interface FontDataAPI {
	listUserFonts(options?: PaginationOptions): SdkResultAsync<FontListDto>;
	listExtensionFonts(options?: PaginationOptions): SdkResultAsync<FontListDto>;
	get(fontFamilyId: string): SdkResultAsync<FontFamilyDto>;
	find(ids: string[]): SdkResultAsync<FontFamilyDto[]>;
	create(options: CreateFontOptions): SdkResultAsync<FontFamilyDto>;
	update(options: UpdateFontFamilyOptions): SdkResultAsync<FontFamilyDto>;
	delete(ids: string[]): SdkResultAsync<void>;
	destroy(ids: string[]): SdkResultAsync<void>;
	addStyle(options: AddFontStyleOptions): SdkResultAsync<FontFamilyDto>;
	updateStyle(options: UpdateFontStyleOptions): SdkResultAsync<void>;
	deleteStyle(options: DeleteFontStyleOptions): SdkResultAsync<void>;
}

FontFamilyDto​

export interface FontFamilyDto extends CatalogItem {
	styles: FontStyleDto[];
	deletedAt: string | null;
	extension: {
		id: string;
		name?: string;
	} | null;
}

FontStyleDto​

export interface FontStyleDto {
	id: string;
	name: string;
	style: string | null;
	deletedAt: string | null;
}

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;
		aiArtId?: string;
		generatorKey?: string;
	};
}

GenerationCreditUse​

export interface GenerationCreditUse {
	amount: number;
	refunded: number;
}

GenerationInputData​

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

GenerationMeta​

export interface GenerationMeta {
	generationEndsAt?: number;
	generationStartedAt?: number;
	pendingGenerationId: string;
	pendingGeneratorKey?: string;
	operation?: PendingOperation;
}

GenerationStartedResultCommonProps​

export interface GenerationStartedResultCommonProps {
	generationEndsAt?: number;
	generationStartedAt?: number;
	scheduledStartAt?: 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;
		};
	};
	size?: {
		width: number;
		height: number;
		unit: Unit;
	};
	dpi?: number;
	colorModel?: "rgb" | "cmyk";
	removeArtboardBackground?: boolean;
	optimizedQuality?: boolean;
	renderingIntent?: "download" | "pdf";
}

GetObjectParams​

export interface GetObjectParams {
	id: string;
}

GetPreviewImageOptions​

export interface GetPreviewImageOptions {
	targetPixelCount: number;
	format: "png" | "jpg";
	quality: 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 {
	getPaths: (params: GetIllustrationPathsParams) => SdkResultAsync<IllustrationSerializedChildren, SdkError>;
	renamePath: (params: RenameIllustrationPathParams, opts?: DesignApiOptions) => SdkResultAsync<void, SdkError>;
	removePaths: (params: RemoveIllustrationPathParams, opts?: DesignApiOptions) => SdkResultAsync<void, SdkError>;
	togglePathLocked: (params: ToggleLockIllustrationPathParams, opts?: DesignApiOptions) => SdkResultAsync<void, SdkError>;
	togglePathHidden: (params: ToggleHideIllustrationPathParams, opts?: DesignApiOptions) => SdkResultAsync<void, SdkError>;
	addIllustration(params: AddIllustrationParams, opts?: DesignApiOptions): Promise<AddedIllustration>;
	updateIllustration(params: UpdateIllustrationParams, opts?: UpdateObjectApiOptions): NormalizedIllustrationObject;
}

ImageAPI​

export interface ImageAPI {
	addImage(params: AddImageParams, opts?: DesignApiOptions): SdkResultAsync<NormalizedIllustrationImageObject, SdkError>;
	updateImage(params: UpdateImageParams, opts?: UpdateObjectApiOptions): NormalizedIllustrationImageObject;
	updateImageSource(params: UpdateImageSourceParams, opts?: UpdateObjectApiOptions): SdkResultAsync<NormalizedIllustrationImageObject, SdkError>;
	resetImageCrop(params: ResetImageCropParams, opts?: DesignApiOptions): SdkResultAsync<NormalizedIllustrationImageObject, SdkError>;
	resetImageBackgroundRemoval(params: ResetImageBackgroundRemovalParams, opts?: DesignApiOptions): SdkResultAsync<NormalizedIllustrationImageObject, SdkError>;
}

ImageGenerationResult​

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

ImageGenerationStartedResult​

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

ImageUploadAPI​

export interface ImageUploadAPI {
	upload: (params: {
		blob: Blob;
	}) => SdkResultAsync<UserImageUpload[], Error>;
	uploadTemp: (params: {
		blob: Blob;
	}) => SdkResultAsync<TempUserImageUpload[], Error>;
}

KittlContext​

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

KittlSDK​

export interface KittlSDK extends KittlSDKLifecycle, KittlSDKEditorAPIs, KittlSDKFileBrowserAPI {
}

KittlSDKEditorAPIs​

export interface KittlSDKEditorAPIs {
	ai: AsyncAIAPI;
	data: AsyncDataAPI;
	design: AsyncDesignAPI;
	export: AsyncExportAPI;
	designStore: AsyncDesignStateAPI;
	appStore: AsyncAppStateSubscriptionAPI;
	context: AsyncContextAPI;
	dragAndDrop: PublicDragAndDropAPI;
	state: AsyncAppStateAPI;
	auth: AsyncAuthAPI;
	upload: AsyncUploadAPI;
	stateless: AsyncStatelessAPI;
	font: AsyncFontAPI;
	createBatch: () => Promise<AsyncBatchDesignAPI>;
}

KittlSDKFileBrowserAPI​

export interface KittlSDKFileBrowserAPI {
	fileBrowser: FileBrowserAPI;
}

KittlSDKLifecycle​

export interface KittlSDKLifecycle {
	loaded: boolean;
	onLoadedCallback: (() => void) | null;
	onReady: (cb: () => void) => void;
}

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;
}

LoadingCardAPI​

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

MockupDataAPI​

export interface MockupDataAPI {
	get(id: number): SdkResultAsync<CatalogItem>;
	getOverview(options?: Pick<PaginationOptions, "sort">): SdkResultAsync<MockupOverviewDto>;
	getGroup(groupId: string, options?: PaginationOptions): SdkResultAsync<MockupGroupDto>;
	search(query: string, options?: PaginationOptions): SdkResultAsync<PaginatedResult<CatalogItem>>;
	getSuggestions(): SdkResultAsync<MockupSuggestions>;
}

MockupGroupDto​

export interface MockupGroupDto {
	group: {
		id: string;
		name: string;
	};
	data: PaginatedResult<CatalogItem>;
}

MockupOverviewDto​

export interface MockupOverviewDto {
	overview: MockupOverviewGroupDto[];
}

MockupOverviewGroupDto​

export interface MockupOverviewGroupDto {
	id: string;
	name: string;
	mockups: CatalogItem[];
	total: number;
}

MockupSuggestions​

export interface MockupSuggestions {
	tags: string[];
	groups: string[];
}

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 {
	setColors(params: SetColorsParams, opts?: DesignApiOptions): void;
	getColors(params: GetColorsParams): SDKColorEntry[];
	setLockedState(params: SetLockedParams, opts?: DesignApiOptions): WithLocked;
	removeObject(params: RemoveObjectParams, opts?: DesignApiOptions): RemoveObjectResult | null;
	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;
	};
}

PaginatedResult​

export interface PaginatedResult<T> {
	items: T[];
	total?: number;
	hasMore: boolean;
}

PaginationOptions​

export interface PaginationOptions {
	take?: number;
	skip?: number;
	sort?: string;
	cursor?: 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;
	};
}

PlacementAPI​

export interface PlacementAPI {
	getSmartPlacement(params: SmartPlacementInput, opts?: {
		batchClient?: BatchClient<NormalizedDesignState>;
	}): SmartPlacementOutput;
}

PublicDragAndDropAPI​

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

PublicExportAPI​

export interface PublicExportAPI {
	bypassExportDialog: BypassExportDialog;
	showExportModal: <Mime extends ExportMimeType>(request: ExportRequest<Mime>) => Promise<ExportResult>;
}

RemoveObjectParams​

export interface RemoveObjectParams {
	id: string;
	skipIfMissing?: boolean;
}

RemoveObjectResult​

export interface RemoveObjectResult {
	removedObjectId: string;
}

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;
	};
}

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?: UpdateObjectApiOptions): 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>;
	updateBackgroundImage(params: UpdateSmartboardBackgroundImageParams, opts?: DesignApiOptions): Promise<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?: ImplementSubStateOptions): Partial<NormalizedDesignState>;
	getState(): NormalizedDesignState;
}

StructureObjectMeta​

export interface StructureObjectMeta {
	textBadge?: {
		styleId: string;
	};
	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?: UpdateObjectApiOptions): 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;
}

UpdateFontFamilyOptions​

export interface UpdateFontFamilyOptions {
	id: string;
	name: string;
}

UpdateFontStyleOptions​

export interface UpdateFontStyleOptions {
	fontFamilyId: string;
	id: string;
	style: string;
}

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: ImageUploadAPI;
}

UserTokenResult​

export interface UserTokenResult {
	success: true;
	token: string;
}

VideoAPI​

export interface VideoAPI {
	addVideo(params: AddVideoParams, opts?: DesignApiOptions): Promise<NormalizedVideoObject>;
	updateVideo(params: UpdateVideoParams, opts?: UpdateObjectApiOptions): NormalizedVideoObject;
	removePlaylistItem(params: RemoveVideoPlaylistItemParams, opts?: DesignApiOptions): NormalizedVideoObject;
	reorderPlaylistItem(params: ReorderVideoPlaylistItemParams, opts?: DesignApiOptions): NormalizedVideoObject;
	addPlaylistItem(params: AddVideoPlaylistItemParams, 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;
}