@kittl/sdk 0.0.8 → 0.0.9

package/dist/sharedFileBrowser/sdk.d.ts

@@ -0,0 +1,2752 @@
+declare abstract class BatchClient<T extends Record<string, unknown>> {
+	abstract getPatches(): PatchTree<T>[];
+	abstract getOrigin(): Origin;
+	abstract getHistoryOrigin(): HistoryOrigins;
+	abstract getWorkingState(): KittlStateStore<T>;
+	abstract commit(): void;
+}
+declare abstract class KittlStateStore<T extends Record<string, unknown>> {
+	abstract getSnapshot(): T;
+	abstract subscribe<U>(selector: Selector<T, U>, callback: (selected: U, meta: {
+		patch: PatchTree<T>[];
+		senderOrigin: Origin;
+	}) => void, subscriberOrigin?: Origin, options?: SubscribeOptions): () => void;
+	abstract internalPatch(args: InternalPatchArgs<T>): void;
+	abstract resetWithState(state: T, origin?: Origin): void;
+}
+declare class SdkBadInputError extends Error {
+	readonly name: "SdkBadInputError";
+	readonly cause?: Error;
+	constructor(message: string, cause?: Error);
+}
+declare class SdkInternalError extends Error {
+	readonly name: "SdkInternalError";
+	readonly cause?: Error;
+	constructor(message: string, cause?: Error);
+}
+declare const BASIC_SHAPE_DEFAULT_VALUES: {
+	defaultIcon: LayerIconType | undefined;
+	shadowOptions?: {
+		color?: string | undefined | null;
+		blur?: number | undefined;
+		offset?: number;
+		angle?: number;
+	};
+	gradients?: StateGradientInfo | undefined;
+	clipPathMaskId?: string | undefined | null;
+	childrenInfo?: {
+		objectName?: string;
+		id: string;
+		fallbackObjectName: string | null;
+		objectNameLayout?: WithObjectLayout;
+		fallbackObjectNameLayout?: WithObjectLayout;
+	} | undefined;
+	hiddenColors?: Record<string, NonNullable<Color>> | undefined;
+	inLoadingStage?: boolean | undefined;
+	objectName: string;
+	skewX: number | undefined;
+	skewY: number | undefined;
+	width: number;
+	height: number;
+	scaleX: number;
+	scaleY: number;
+	angle: number;
+	top: number;
+	left: number;
+	flipX: boolean;
+	flipY: boolean;
+	name?: string | undefined;
+	defaultName: string | undefined;
+	locked?: boolean | undefined;
+	hidden?: boolean | undefined;
+	opacity?: number | undefined;
+	stroke?: string | null;
+	strokeWidth?: number;
+	fill?: ColorInfo[] | undefined;
+	scalingCorners?: boolean | undefined;
+	cornerRadii?: SerializableCornerRadii | undefined;
+	id: DesignObjectId;
+	version: string;
+	type: ObjectType.BasicShape;
+};
+declare const BasicShapeType: {
+	readonly RECTANGLE: "rectangle";
+	readonly CIRCLE: "ellipse";
+	readonly STAR: "star";
+	readonly TRIANGLE: "polygon";
+};
+declare const DEFAULT_VALUES$1: {
+	globalCompositeOperation: BlendMode;
+	stroke?: string | null;
+	strokeWidth?: number;
+	shadowOptions?: {
+		color?: string | undefined | null;
+		blur?: number | undefined;
+		offset?: number;
+		angle?: number;
+	};
+	opacity?: number | undefined;
+	objectName: string;
+	width: number;
+	height: number;
+	scaleX: number;
+	scaleY: number;
+	angle: number;
+	top: number;
+	left: number;
+	flipX: boolean;
+	flipY: boolean;
+	name?: string | undefined;
+	defaultName: string | undefined;
+	locked?: boolean | undefined;
+	inLoadingStage?: boolean | undefined;
+	clipPathMaskId?: string | undefined | null;
+	hidden?: boolean | undefined;
+	filters: SerialisedPhotoFilter[] | undefined;
+	fill?: ColorInfo[] | undefined;
+	cropX?: number | undefined;
+	cropY?: number | undefined;
+	cropWidth?: number | undefined;
+	cropHeight?: number | undefined;
+	id: DesignObjectId;
+	version: string;
+	type: ObjectType.IllustrationImage;
+	isGeneratedByAi?: boolean;
+	aiArtId?: string;
+	generatedContentId?: string;
+	generation?: {
+		meta?: GenerationMeta;
+		generationId?: string;
+		aiArtId?: string;
+		generatorKey?: string;
+	};
+};
+declare const DEFAULT_VALUES$2: {
+	cropX?: number | undefined;
+	cropY?: number | undefined;
+	cropWidth?: number | undefined;
+	cropHeight?: number | undefined;
+	shadowOptions?: {
+		color?: string | undefined | null;
+		blur?: number | undefined;
+		offset?: number;
+		angle?: number;
+	};
+	stroke?: string | null;
+	strokeWidth?: number;
+	opacity?: number | undefined;
+	width: number;
+	height: number;
+	scaleX: number;
+	scaleY: number;
+	angle: number;
+	top: number;
+	left: number;
+	flipX: boolean;
+	flipY: boolean;
+	name?: string | undefined;
+	defaultName: string | undefined;
+	locked?: boolean | undefined;
+	hidden?: boolean | undefined;
+	id: DesignObjectId;
+	version: string;
+	type: ObjectType.Video;
+};
+declare const DEFAULT_VALUES: {
+	shapes: never[];
+	operation: ShapeBooleanOperation;
+	clipPathMaskId?: string | undefined | null;
+	scalingCorners?: boolean | undefined;
+	cornerRadii?: SerializableCornerRadii | undefined;
+	childrenInfo?: {
+		objectName?: string;
+		id: string;
+		fallbackObjectName: string | null;
+		objectNameLayout?: WithObjectLayout;
+		fallbackObjectNameLayout?: WithObjectLayout;
+	} | undefined;
+	shadowOptions?: {
+		color?: string | undefined | null;
+		blur?: number | undefined;
+		offset?: number;
+		angle?: number;
+	};
+	gradients?: StateGradientInfo | undefined;
+	opacity?: number | undefined;
+	hiddenColors?: Record<string, NonNullable<Color>> | undefined;
+	stroke?: string | null;
+	strokeWidth?: number;
+	fill?: ColorInfo[] | undefined;
+	locked?: boolean | undefined;
+	hidden?: boolean | undefined;
+	skewX: number | undefined;
+	skewY: number | undefined;
+	width: number;
+	height: number;
+	scaleX: number;
+	scaleY: number;
+	angle: number;
+	top: number;
+	left: number;
+	flipX: boolean;
+	flipY: boolean;
+	name?: string | undefined;
+	defaultName: string | undefined;
+	id: DesignObjectId;
+	version: string;
+	type: ObjectType.CombinedShape;
+};
+declare const EXPORT_MIME_TYPES: {
+	readonly jpeg: "image/jpeg";
+	readonly mp4: "video/mp4";
+	readonly pdf: "application/pdf";
+	readonly png: "image/png";
+	readonly svg: "image/svg+xml";
+};
+declare const GUIDE_DEFAULT_VALUES: {
+	id: DesignObjectId;
+	version: string;
+	type: ObjectType.Guide;
+};
+declare const GenerationStatus: {
+	readonly CREATED: "CREATED";
+	readonly QUEUED: "QUEUED";
+	readonly STARTED: "STARTED";
+	readonly COMPLETE: "COMPLETE";
+	readonly FAILED: "FAILED";
+	readonly CANCELLED: "CANCELLED";
+};
+declare const ILLUSTRATION_DEFAULT_VALUES: {
+	hiddenColors?: Record<string, NonNullable<Color>> | undefined;
+	clipPathMaskId?: string | undefined | null;
+	isGeneratedByAi?: boolean;
+	aiArtId?: string;
+	generatedContentId?: string;
+	generation?: {
+		meta?: GenerationMeta;
+		generationId?: string;
+		aiArtId?: string;
+		generatorKey?: string;
+	};
+	childrenInfo?: {
+		objectName?: string;
+		id: string;
+		fallbackObjectName: string | null;
+		objectNameLayout?: WithObjectLayout;
+		fallbackObjectNameLayout?: WithObjectLayout;
+	} | undefined;
+	shadowOptions?: {
+		color?: string | undefined | null;
+		blur?: number | undefined;
+		offset?: number;
+		angle?: number;
+	};
+	gradients?: StateGradientInfo | undefined;
+	opacity?: number | undefined;
+	stroke?: string | null;
+	strokeWidth?: number;
+	fill?: ColorInfo[] | undefined;
+	inLoadingStage?: boolean | undefined;
+	locked?: boolean | undefined;
+	hidden?: boolean | undefined;
+	objectName: string;
+	width: number;
+	height: number;
+	scaleX: number;
+	scaleY: number;
+	angle: number;
+	top: number;
+	left: number;
+	flipX: boolean;
+	flipY: boolean;
+	name?: string | undefined;
+	defaultName: string | undefined;
+	id: DesignObjectId;
+	version: string;
+	type: ObjectType.Illustration;
+};
+declare const LOADING_CARD_DEFAULT_VALUES: {
+	locked?: boolean | undefined;
+	hidden?: boolean | undefined;
+	width: number;
+	height: number;
+	scaleX: number;
+	scaleY: number;
+	angle: number;
+	top: number;
+	left: number;
+	flipX: boolean;
+	flipY: boolean;
+	name?: string | undefined;
+	defaultName: string | undefined;
+	id: DesignObjectId;
+	version: string;
+	type: ObjectType.LoadingCard;
+};
+declare const MASK_DEFAULT_VALUES: {
+	inLoadingStage?: boolean | undefined;
+	opacity?: number | undefined;
+	locked?: boolean | undefined;
+	hidden?: boolean | undefined;
+	objectName: string;
+	width: number;
+	height: number;
+	scaleX: number;
+	scaleY: number;
+	angle: number;
+	top: number;
+	left: number;
+	flipX: boolean;
+	flipY: boolean;
+	name?: string | undefined;
+	defaultName: string | undefined;
+	id: DesignObjectId;
+	version: string;
+	type: ObjectType.Mask;
+};
+declare const MOCKUP_DESIGN_DEFAULT_VALUES: {
+	hidden?: boolean | undefined;
+	locked?: boolean | undefined;
+	width: number;
+	height: number;
+	scaleX: number;
+	scaleY: number;
+	angle: number;
+	top: number;
+	left: number;
+	flipX: boolean;
+	flipY: boolean;
+	id: DesignObjectId;
+	version: string;
+	type: ObjectType.MockupDesign;
+};
+declare const PATH_TEXT_DEFAULT_VALUES: {
+	fontSize: number;
+	lineHeight: number;
+	textAlignment: TextAlignment;
+	letterSpacing: number;
+	stroke: string;
+	useLigatures: boolean;
+	strokeWidth?: number;
+	fill?: Color | undefined;
+	opacity?: number | undefined;
+	locked?: boolean | undefined;
+	hidden?: boolean | undefined;
+	width: number;
+	height: number;
+	scaleX: number;
+	scaleY: number;
+	angle: number;
+	top: number;
+	left: number;
+	flipX: boolean;
+	flipY: boolean;
+	name?: string | undefined;
+	defaultName: string | undefined;
+	id: DesignObjectId;
+	version: string;
+	type: ObjectType.PathText;
+};
+declare const PendingOperation: {
+	readonly GENERATE: "generate";
+	readonly INPAINT: "inpaint";
+	readonly ERASE_AND_FILL: "eraseAndFill";
+	readonly VECTORIZE: "vectorize";
+	readonly LAYERIZE: "layerize";
+	readonly UPSCALE: "upscale";
+	readonly REMOVE_BACKGROUND: "removeBackground";
+	readonly REFRAME: "reframe";
+};
+declare const RICH_TEXT_DEFAULT_VALUES: {
+	opacity?: number | undefined;
+	stroke?: string | null;
+	strokeWidth?: number;
+	fill?: Color | undefined;
+	locked?: boolean | undefined;
+	hidden?: boolean | undefined;
+	width: number;
+	height: number;
+	scaleX: number;
+	scaleY: number;
+	angle: number;
+	top: number;
+	left: number;
+	flipX: boolean;
+	flipY: boolean;
+	name?: string | undefined;
+	defaultName: string | undefined;
+	id: DesignObjectId;
+	version: string;
+	type: ObjectType.RichText;
+};
+declare const ResultType: {
+	readonly VIDEO: "video";
+	readonly IMAGE: "image";
+	readonly ERROR: "error";
+};
+declare const UploadType: {
+	readonly EXTENSION: "EXTENSION";
+	readonly AI_GENERATED: "AI_GENERATED";
+	readonly AI_GENERATED_SETS: "AI_GENERATED_SETS";
+	readonly AI_UPSCALED: "AI_UPSCALED";
+	readonly AI_EDITED: "AI_EDITED";
+	readonly MOCKUP: "MOCKUP";
+	readonly CLIPPED: "CLIPPED";
+	readonly BRAND_KIT: "BRAND_KIT";
+	readonly QUICK_EDIT: "QUICK_EDIT";
+};
+declare const backgroundType = "background";
+declare const clippingMaskType = "clippingMask";
+declare const pathType = "path";
+declare const stringColorKeys: readonly [
+	"stroke",
+	"shadow",
+	"decoration"
+];
+declare const structuralGroupType = "structuralGroup";
+declare enum Action {
+	MERGE = "MERGE",
+	SET = "SET",
+	DELETE = "DELETE"
+}
+declare enum BlendMode {
+	Normal = "normal",
+	SourceOver = "source-over",
+	Multiply = "multiply",
+	Screen = "screen",
+	Overlay = "overlay",
+	SoftLight = "soft-light",
+	HardLight = "hard-light",
+	ColorDodge = "color-dodge",
+	ColorBurn = "color-burn",
+	Lighten = "lighten",
+	Darken = "darken",
+	Difference = "difference",
+	Exclusion = "exclusion",
+	Lighter = "lighter",
+	Hue = "hue",
+	Saturation = "saturation",
+	Color = "color",
+	Luminosity = "luminosity",
+	AlphaMask = "destination-out"
+}
+declare enum BoardLayout {
+	Custom = "custom",
+	Standard = "standard",
+	TShirt = "tshirt",
+	BusinessCard = "businesscard",
+	A4 = "a4",
+	A5 = "a5",
+	Poster = "poster",
+	InstagramPost = "instagramPost",
+	InstagramPostPortrait = "instagramPostPortrait",
+	instagramPostSquare = "instagramPostSquare",
+	InstagramPostLandscape = "instagramPostLandscape",
+	InstagramStory = "instagramStory",
+	InstagramReel = "instagramReel",
+	FacebookPost = "facebookPost",
+	FacebookPostSquare = "facebookPostSquare",
+	FacebookPostLandscape = "facebookPostLandscape",
+	FacebookStory = "facebookStory",
+	YouTubeThumbnail = "youtubeThumbnail",
+	YouTubeProfileBanner = "youtubeProfileBanner",
+	YouTubeAdBanner = "youtubeAdBanner",
+	XPost = "xPost",
+	XHeader = "xHeader",
+	XCarouselAd = "xCarouselAd",
+	PinterestPin = "pinterestPin",
+	WebBannerAd = "webBannerAd",
+	Postcard = "postcard",
+	Letterhead = "letterhead",
+	Flyer = "flyer",
+	Brochure = "brochure",
+	Logo = "logo",
+	Presentation = "presentation",
+	AmazonTShirt = "amazonTShirt",
+	PrintfulTShirt = "printfulTShirt",
+	PrintfulAop = "printfulAop",
+	PrintfulHat = "printfulHat",
+	RedBubbleStandard = "redBubbleStandard",
+	RedBubbleSticker = "redBubbleSticker",
+	TeepublicStandard = "teepublicStandard",
+	DisplatePoster = "displatePoster",
+	PrintifyStandard = "printifyStandard",
+	PrintifyAop = "printifyAop",
+	PrintifyHoodie = "printifyHoodie",
+	PrintifyMug = "printifyMug",
+	PrintifyNotebook = "printifyNotebook",
+	PrintifySticker = "printifySticker",
+	AwkwardStylesTShirt = "awkwardStylesTShirt"
+}
+declare enum GradientType {
+	Linear = "linear",
+	Radial = "radial"
+}
+declare enum HistoryOrigins {
+	Tracked = "change:origin",
+	Untracked = "untracked:origin"
+}
+declare enum ImageFilterType {
+	Saturation = "Saturation",
+	Contrast = "Contrast",
+	Brightness = "Brightness",
+	Vibrance = "Vibrance",
+	HueRotation = "HueRotation",
+	Noise = "Noise",
+	Blur = "Blur",
+	Convolute = "Convolute",
+	Pixelate = "Pixelate",
+	RemoveColor = "RemoveColor"
+}
+declare enum InpaintingSelectionMode {
+	ADD = "add",
+	SUBTRACT = "subtract"
+}
+declare enum ObjectType {
+	Artboard = "artboard",
+	Smartboard = "smartboard",
+	Videoboard = "videoboard",
+	MockupBoard = "mockupBoard",
+	Illustration = "illustration",
+	IllustrationImage = "illustrationImage",
+	Video = "video",
+	BasicShape = "basicShape",
+	VectorPath = "vectorPath",
+	CombinedShape = "combinedShape",
+	PathText = "pathText",
+	Mask = "mask",
+	RichText = "RichText",
+	Guide = "guide",
+	LoadingCard = "loadingCard",
+	MockupDesign = "mockupDesign",
+	ActiveSelection = "activeSelection",
+	ArtboardTitle = "artboardTitle",
+	ArtboardTitleIcon = "artboardTitleIcon",
+	OverlayTexture = "overlayTexture",
+	CustomTextbox = "CustomTextbox",
+	ClipPath = "clipPath",
+	Path = "path",
+	Ruler = "ruler",
+	WarpControlRootPoint = "warpControlRootPoint",
+	Group = "group",
+	Circle = "circle",
+	Rect = "rect"
+}
+declare enum Orientation {
+	HORIZONTAL = "horizontal",
+	VERTICAL = "vertical"
+}
+declare enum Origin {
+	CRDT = 1,
+	CANVAS = 2,
+	UI = 4,
+	VOLATILE = 8,
+	EVENTS_SYNC = 16,
+	API = 32,
+	UNDO_REDO = 64
+}
+declare enum TextAlignment {
+	right = "right",
+	left = "left",
+	center = "center",
+	justify = "justify",
+	justifyLegacy = "justify-legacy"
+}
+declare enum Unit {
+	px = "px",
+	in = "in",
+	mm = "mm"
+}
+export declare const kittl: SharedFileBrowserKittlSDK;
+export declare function unwrapResult<T>(result: SdkResult<T, Error>): T;
+export interface AIGenerationInputSettings {
+	prompt: string;
+	taskType?: AIGenerationModelTaskType;
+	promptStyleId?: number;
+	model?: {
+		id: string;
+	};
+	additionalParams?: Record<string, unknown>;
+	actionOrigin?: AIGenerationActionOrigin;
+	type: AIGenerationContentType;
+	referenceImageMode?: AIGenerationReferenceImageMode;
+}
+export interface AIGenerationOutputSettings {
+	id?: string;
+	dimensions: {
+		width: number;
+		height: number;
+	};
+}
+export interface AddFontStyleOptions {
+	fontFamilyId: string;
+	files: Blob[];
+	styles: string[];
+}
+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;
+}
+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>;
+}
+export interface AsyncAppStateAPI extends WithAsync<AppStateAPI> {
+	setCustomCanvasMode<const Id extends string>(params: SetCustomCanvasModeParams<Id>, origin?: Origin): Promise<BridgedSdkResult<void>>;
+}
+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>;
+}
+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>>;
+}
+export interface AsyncBatchDesignAPI extends AsyncDesignAPI {
+	commit: () => Promise<void>;
+}
+export interface AsyncContextAPI extends Omit<WithAsync<ContextAPI>, "subscribe"> {
+	subscribe(callback: ContextSubscriptionCallback): Promise<() => void>;
+}
+export interface AsyncDataAPI extends WithAsync<DataAPI> {
+}
+export interface AsyncDesignAPI extends WithAsync<WithOptsRemoved<DesignAPI>> {
+}
+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>;
+}
+export interface AsyncExportAPI extends Omit<WithAsync<ExportAPI>, "showExportModal"> {
+	showExportModal<Mime extends ExportMimeType>(request: ExportRequest<Mime>): Promise<BridgedSdkResult<ExportResult>>;
+}
+export interface AsyncFontAPI extends WithAsync<FontAPI> {
+}
+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>;
+}
+export interface AsyncUploadAPI extends WithAsync<UploadAPI> {
+}
+export interface AuthExchangeRequest {
+	code: string;
+	code_verifier?: string;
+	provider: string;
+	params?: Record<string, unknown>;
+	headers?: Record<string, string>;
+}
+export interface AuthGetTokenRequest {
+	provider: string;
+}
+export interface AuthLogoutRequest {
+	provider?: string;
+}
+export interface AuthRefreshRequest {
+	provider: string;
+}
+export interface AuthStartRequest {
+	provider: string;
+	params?: Record<string, string | number | boolean>;
+	generatePKCE?: boolean;
+}
+export interface AuthStartResult {
+	code: string;
+	code_verifier?: string;
+}
+export interface AuthTokenResponse {
+	access_token?: string;
+	refresh_token?: string;
+	expires_in?: number;
+	[key: string]: unknown;
+}
+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;
+}
+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;
+}
+export interface BaseStandardBoard<T extends ArtboardOptions = ArtboardOptions> {
+	id: string;
+	artboard: T;
+	title?: string;
+	texture?: TextureOptions;
+	backgroundImage?: BackgroundImageOptions;
+	originTemplateId?: string;
+}
+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;
+}
+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>;
+}
+export interface CatalogItem {
+	id: string;
+	name: string;
+	previewImages: string[];
+}
+export interface ConfigAPI {
+	setConfig(config: Partial<DesignConfig>, opts?: DesignApiOptions): void;
+}
+export interface ContextAPI {
+	get(input?: ContextGetInput): KittlContext;
+	subscribe(callback: ContextSubscriptionCallback): () => void;
+}
+export interface ContextGetInput {
+	iframe?: Pick<HTMLIFrameElement, "getBoundingClientRect">;
+}
+export interface CreateFontOptions {
+	name: string;
+	files: Blob[];
+	styles: string[];
+	previewImage?: Blob;
+}
+export interface CreateLoadingCardInput extends CreateElementWithPositionAndSize {
+	imageGenerationId?: string;
+	startedAt?: number;
+	generatingModelKey?: string;
+	generationAverageSpeed?: number;
+	name?: string;
+}
+export interface CustomCanvasModeStateById {
+}
+export interface DataAPI {
+	mockups: MockupDataAPI;
+	fonts: FontDataAPI;
+}
+export interface DecorationOptions {
+	type: "horizontalLines" | "colorCut" | "obliqueLines" | "fadingColorCut";
+	color: string | null;
+	weight: number;
+	distance: number;
+	cutDistance: number;
+}
+export interface DeleteFontStyleOptions {
+	fontFamilyId: string;
+	id: string;
+}
+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;
+}
+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;
+}
+export interface DragAndDropDropImageInput {
+	x: number;
+	y: number;
+	grabOffsetX?: number;
+	grabOffsetY?: number;
+	src: string;
+	imgWidth?: number;
+	imgHeight?: number;
+	persistImage?: boolean;
+}
+export interface DragAndDropOffset {
+	left: number;
+	top: number;
+}
+export interface DragAndDropStartDragImageEventInput {
+	event: DragEvent;
+	img: HTMLImageElement;
+	persistImage?: boolean;
+}
+export interface ErrorGenerationResult {
+	type: typeof ResultType.ERROR;
+	message: string;
+	subtitle: string;
+	status: "warning" | "error";
+	isRecognized?: boolean;
+	errorKey?: string;
+}
+export interface FileBrowserAPI {
+	registerUploadBrowser: (tab: Omit<FileBrowserTab, "onEvent">) => Promise<SdkResponse<void>>;
+}
+export interface FontAPI {
+	createFont: (params: {
+		name: string;
+		files: Blob[];
+		styles: string[];
+		previewImage?: Blob;
+	}) => SdkResultAsync<UploadedFontFamily, Error>;
+}
+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>;
+}
+export interface FontFamilyDto extends CatalogItem {
+	styles: FontStyleDto[];
+	deletedAt: string | null;
+	extension: {
+		id: string;
+		name?: string;
+	} | null;
+}
+export interface FontStyleDto {
+	id: string;
+	name: string;
+	style: string | null;
+	deletedAt: string | null;
+}
+export interface FontVariation {
+	name: string;
+	min: number;
+	max: number;
+	default: number;
+}
+export interface GeneratableBoard<T extends Record<string, unknown> = never> {
+	generationSettings?: T;
+}
+export interface GeneratableObject {
+	generation?: {
+		meta?: GenerationMeta;
+		generationId?: string;
+		aiArtId?: string;
+		generatorKey?: string;
+	};
+}
+export interface GenerationCreditUse {
+	amount: number;
+	refunded: number;
+}
+export interface GenerationInputData {
+	prompt?: string;
+	style?: {
+		id: number;
+	};
+	model?: {
+		id: string;
+	};
+}
+export interface GenerationMeta {
+	generationEndsAt?: number;
+	generationStartedAt?: number;
+	pendingGenerationId: string;
+	pendingGeneratorKey?: string;
+	operation?: PendingOperation;
+}
+export interface GenerationStartedResultCommonProps {
+	generationEndsAt?: number;
+	generationStartedAt?: number;
+	scheduledStartAt?: number;
+}
+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";
+}
+export interface GetObjectParams {
+	id: string;
+}
+export interface GetPreviewImageOptions {
+	targetPixelCount: number;
+	format: "png" | "jpg";
+	quality: number;
+}
+export interface GradientColorStop {
+	color: string | null;
+	offset: number;
+	opacity?: number;
+}
+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;
+}
+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[];
+}
+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;
+}
+export interface GuideAPI {
+	createGuide(input: CreateGuideInput, opts?: DesignApiOptions): NormalizedGuideObject;
+	updateGuide(input: UpdateGuideInput, opts?: DesignApiOptions): NormalizedGuideObject;
+}
+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;
+}
+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>;
+}
+export interface ImageGenerationResult {
+	type: typeof ResultType.IMAGE;
+	objectName: string;
+}
+export interface ImageGenerationStartedResult extends GenerationStartedResultCommonProps {
+	type: typeof ResultType.IMAGE;
+}
+export interface ImageUploadAPI {
+	upload: (params: {
+		blob: Blob;
+	}) => SdkResultAsync<UserImageUpload[], Error>;
+	uploadTemp: (params: {
+		blob: Blob;
+	}) => SdkResultAsync<TempUserImageUpload[], Error>;
+}
+export interface KittlContext {
+	colorScheme: EditorColorScheme;
+	dragAndDrop: {
+		offset: DragAndDropOffset;
+	};
+}
+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>;
+}
+export interface KittlSDKFileBrowserAPI {
+	fileBrowser: FileBrowserAPI;
+}
+export interface KittlSDKLifecycle {
+	loaded: boolean;
+	onLoadedCallback: (() => void) | null;
+	onReady: (cb: () => void) => void;
+}
+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;
+}
+export interface LoadingCardAPI {
+	createLoadingCard(input: CreateLoadingCardInput, opts?: DesignApiOptions): NormalizedLoadingCardObject;
+	updateLoadingCard(input: UpdateLoadingCardInput, opts?: UpdateObjectApiOptions): NormalizedLoadingCardObject;
+}
+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>;
+}
+export interface MockupGroupDto {
+	group: {
+		id: string;
+		name: string;
+	};
+	data: PaginatedResult<CatalogItem>;
+}
+export interface MockupOverviewDto {
+	overview: MockupOverviewGroupDto[];
+}
+export interface MockupOverviewGroupDto {
+	id: string;
+	name: string;
+	mockups: CatalogItem[];
+	total: number;
+}
+export interface MockupSuggestions {
+	tags: string[];
+	groups: string[];
+}
+export interface MockupboardAPI {
+	addMockupBoard(params: AddMockupBoardParams, opts?: DesignApiOptions): NormalizedStandardBoard<MockupBoardOptions>;
+	addMockupDesignObject(params: AddMockupDesignObjectParams, opts?: DesignApiOptions): NormalizedMockupDesignObject;
+	updateMockupBoard(params: UpdateMockupBoardParams, opts?: DesignApiOptions): NormalizedStandardBoard<MockupBoardOptions>;
+}
+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;
+	};
+}
+export interface PaginatedResult<T> {
+	items: T[];
+	total?: number;
+	hasMore: boolean;
+}
+export interface PaginationOptions {
+	take?: number;
+	skip?: number;
+	sort?: string;
+	cursor?: string;
+}
+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;
+	};
+}
+export interface PlacementAPI {
+	getSmartPlacement(params: SmartPlacementInput, opts?: {
+		batchClient?: BatchClient<NormalizedDesignState>;
+	}): SmartPlacementOutput;
+}
+export interface PublicDragAndDropAPI {
+	startDragImageEvent(input: DragAndDropStartDragImageEventInput): void;
+	dropImage(input: DragAndDropDropImageInput): Promise<string | null>;
+}
+export interface PublicExportAPI {
+	bypassExportDialog: BypassExportDialog;
+	showExportModal: <Mime extends ExportMimeType>(request: ExportRequest<Mime>) => Promise<ExportResult>;
+}
+export interface RemoveObjectParams {
+	id: string;
+	skipIfMissing?: boolean;
+}
+export interface RemoveObjectResult {
+	removedObjectId: string;
+}
+export interface RichTextCompressedStylesV1 {
+	version: "v1";
+	[lineIndex: LineIndex]: {
+		charsAt: CharacterIndex[];
+		styles: Partial<RichTextSerializedCharacterStyle>;
+	}[];
+}
+export interface RichTextCompressedStylesV2 {
+	version: "v2";
+	customStyles: Record<string, Partial<RichTextSerializedCharacterStyle>>;
+	[lineIndex: LineIndex]: {
+		charsAt: [
+			CharacterIndex,
+			SequenceLength
+		][];
+		styleId: string;
+	}[];
+}
+export interface RotateObjectParams {
+	id: string;
+	angle: number;
+	origin?: {
+		x: OriginX;
+		y: OriginY;
+	};
+}
+export interface SetHiddenParams {
+	id: string;
+	hidden: boolean;
+}
+export interface SetLockedParams {
+	id: string;
+	locked: boolean;
+}
+export interface ShadowOptions {
+	angle: number;
+	offset: number;
+	blur: number;
+	color: string | null;
+}
+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;
+}
+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>>;
+}
+export interface SpendCreditsOptions {
+	amount: number;
+	message: string;
+	onAccept?: () => void;
+	onDecline?: () => void;
+}
+export interface SpendCreditsResult {
+	success: boolean;
+}
+export interface StandardArtboardOptions extends BaseStandardArtboardOptions<ObjectType.Artboard> {
+}
+export interface StartGenerationResult {
+	generationId: string;
+}
+export interface StateAPI {
+	implementSubState(params: Partial<NormalizedDesignState>, opts?: ImplementSubStateOptions): Partial<NormalizedDesignState>;
+	getState(): NormalizedDesignState;
+}
+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;
+}
+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;
+}
+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>;
+}
+export interface TextureOptions {
+	texture: string;
+	mode: BlendMode;
+	opacity: number;
+	hidden?: boolean;
+	loaded?: boolean;
+	isAlphaMask?: boolean;
+	renderClip?: boolean;
+}
+export interface TransformOptions {
+	type: "freeLine" | "freeForm" | "circle" | "angle" | "arch" | "rise" | "wave" | "flag" | null;
+	directionInverted?: boolean;
+	curve?: number;
+	isChanging?: boolean;
+}
+export interface UpdateFontFamilyOptions {
+	id: string;
+	name: string;
+}
+export interface UpdateFontStyleOptions {
+	fontFamilyId: string;
+	id: string;
+	style: string;
+}
+export interface UpdateGuideInput {
+	id: string;
+	top?: number;
+	left?: number;
+}
+export interface UpdateLoadingCardInput {
+	id: string;
+	position?: CreateElementWithPositionAndSize["position"];
+	size?: CreateElementWithPositionAndSize["size"];
+	imageGenerationId?: string;
+	startedAt?: number;
+	generatingModelKey?: string;
+	generationAverageSpeed?: number;
+	name?: string;
+}
+export interface UploadAPI {
+	image: ImageUploadAPI;
+}
+export interface UserTokenResult {
+	success: true;
+	token: string;
+}
+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>;
+}
+export interface VideoGenerationResult {
+	type: typeof ResultType.VIDEO;
+	status: "PROCESSING" | "READY" | "FAILED";
+	playbackId?: string;
+	duration?: number;
+	aspectRatio?: string;
+	hostingProvider?: "MUX";
+}
+export interface VideoGenerationStartedResult extends GenerationStartedResultCommonProps {
+	type: typeof ResultType.VIDEO;
+}
+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>>;
+}
+export interface WithHidden {
+	hidden?: boolean | undefined;
+}
+export interface WithLocked {
+	locked?: boolean | undefined;
+}
+export interface WithObjectLayout {
+	width: number;
+	height: number;
+	scaleX: number;
+	scaleY: number;
+	angle: number;
+	top: number;
+	left: number;
+	flipX: boolean;
+	flipY: boolean;
+}
+export type AIGenerationActionOrigin = "COPILOT" | "RIGHT_PANEL" | "LEFT_PANEL" | "MICRO_APP" | "IMAGE_SETS" | "AI_CHAT" | "SMARTBOARD" | "AI_INPUT_GENERATE_IMAGE" | "AI_INPUT_REMIX_IMAGE" | "AI_INPUT_GENERATE_VIDEO" | "AI_INPUT_MICRO_EDITOR_REMIX" | "AI_INPUT_MICRO_EDITOR_INPAINT" | "AI_HUB_GENERATE_IMAGE" | "AI_HUB_REMIX_IMAGE" | "AI_HUB_GENERATE_VIDEO" | "VIDEOBOARD" | "AGENT" | "AI_HUB_AGENT" | "WORKFLOW" | "MCP" | "MCP_WORKFLOW" | "AI_AGENT" | "AI_AGENT_CHAT" | "AI_AGENT_CHAT_WEBSITE";
+export type AIGenerationContentType = "image" | "video";
+export type AIGenerationModelTaskType = "IMAGE_TO_IMAGE" | "IMAGE_INPAINT" | "IMAGE_OUTPAINT" | "TEXT_TO_IMAGE" | "IMAGE_TO_VIDEO";
+export type AIGenerationReferenceImageMode = "keyframe" | "reference";
+export type APIOptions<T extends Record<string, unknown>> = {
+	batchClient?: BatchClient<T>;
+} | {
+	origin?: Origin;
+	historyOrigin?: HistoryOrigins;
+} | undefined;
+export type AbsolutePosition = {
+	absolute: LeftTopPosition;
+};
+export type ActiveTool = {
+	type: "artboard";
+} | {
+	type: "move";
+} | {
+	type: "hand";
+} | {
+	type: "pen";
+} | {
+	type: "pen-vector-editing";
+} | {
+	type: "comment";
+} | {
+	type: "text";
+} | {
+	type: "shape";
+	shape: BasicShapeType;
+};
+export type AddIllustrationParams = {
+	src: string;
+	objectProperties?: IllustrationProperties;
+} & CreateElementWithPositionAndSize;
+export type AddImageParams = ({
+	src: string;
+} | {
+	width: number;
+	height: number;
+	src?: never;
+}) & GeneratableObject & {
+	objectProperties?: ImageProperties;
+	crop?: ImageCrop;
+} & CreateElementWithPositionAndSize;
+export type AddIntoGroupParams = {
+	groupId: string;
+	objectIds: string[];
+};
+export type AddMockupBoardParams = {
+	inputBoardIds: string[];
+	mockupTemplateId: number;
+	fill?: string;
+	shouldMockupColorMatchArtboard?: boolean;
+	initialDesigns?: AddMockupDesignObjectParams[];
+} & {
+	position: AbsolutePosition | RelativePosition;
+	size: Dimensions;
+};
+export type AddMockupDesignObjectParams = {
+	mockupBoardId: string;
+	inputBoardId: string;
+	mockupTemplateId: number;
+	initialNormalizedUnwarpedRect: MockupDesignRect;
+};
+export type AddSmartboardParams = {
+	linkedBoardIds?: string[];
+} & {
+	position: AbsolutePosition | RelativePosition;
+	size: Dimensions;
+};
+export type AddTextParams = {
+	text: string;
+	id?: string;
+	textProperties?: TextProperties;
+	position: CreateElementWithPositionAndSize["position"];
+	size: Dimensions;
+};
+export type AddVideoParams = {
+	playlist: VideoPlaylistItemInput[];
+	videoSize?: {
+		width: number;
+		height: number;
+	};
+} & CreateElementWithPositionAndSize;
+export type AddVideoPlaylistItemParams = {
+	videoId: string;
+	playlistItem: VideoPlaylistItemInput;
+	playlistItemId?: string;
+	previousPlaylistItemId?: string;
+	nextPlaylistItemId?: string;
+};
+export type AddVideoboardParams = {
+	linkedBoardIds?: string[];
+	video?: {
+		width?: number;
+		height?: number;
+		playlist: VideoPlaylistItemInput[];
+	};
+} & {
+	position: AbsolutePosition | RelativePosition;
+	size: Dimensions;
+};
+export type AddedIllustration = NormalizedIllustrationObject & {
+	hasTextElements: boolean;
+};
+export type AnimateViewportParams = ViewportPatch & ViewportAnimationSettings;
+export type AnimateViewportToBoundsParams = ViewportAnimationSettings & ObjectPositionRect & {
+	viewportPadding?: ViewportBoundsPadding;
+};
+export type AnimateViewportToCenterParams = ViewportAnimationSettings & ObjectPositionRect;
+export type AppState = {
+	selectedObjectsIds: string[];
+	selectedLayersIds: string[];
+	selectedArtboardIds: string[];
+	selectedArtboardsObjectIds: string[];
+	allSelectedObjectsIds: string[];
+	canvasMode: CanvasMode;
+	activeTool: ActiveTool;
+	viewport: Viewport;
+	isDragPanning: boolean;
+	highlightedObjectId: string | null;
+	isViewOnlyMode: boolean;
+	hasLegacyOutOfBoundsObjects: boolean;
+	canvasSettings: SettingsType;
+	penToolSetting: {
+		stroke: string | null | undefined;
+		strokeWidth: number;
+		fill: Color;
+	};
+	outlineLoading: Record<string, boolean>;
+	objectLoading: Record<string, boolean>;
+	pendingOperations: Record<string, PendingOperation>;
+};
+export type AppStateSelectorPath = AppStateTopLevelKey | `${AppStateTopLevelKey}.${string}`;
+export type AppStateTopLevelKey = keyof AppState;
+export type AppStateWithoutModes = Omit<AppState, "canvasMode" | "activeTool" | "viewport" | "isDragPanning" | "highlightedObjectId" | "canvasSettings" | "objectLoading">;
+export type ArtboardLikeType = ObjectType.Artboard | ObjectType.MockupBoard | ObjectType.Smartboard | ObjectType.Videoboard;
+export type ArtboardOptions = StandardArtboardOptions | SmartboardOptions | MockupBoardOptions | VideoboardOptions;
+export type AvailableShadowOptions = Partial<Pick<ShadowOptions, "blur">> & Omit<ShadowOptions, "blur">;
+export type BaseFloatingBoard = {
+	id: string;
+	floating: true;
+};
+export type BasicShapeConfigurableFields = {
+	angle?: BasicShapeSerializedObject["angle"];
+	flipX?: BasicShapeSerializedObject["flipX"];
+	flipY?: BasicShapeSerializedObject["flipY"];
+	hidden?: BasicShapeSerializedObject["hidden"];
+	opacity?: BasicShapeSerializedObject["opacity"];
+	skewX?: BasicShapeSerializedObject["skewX"];
+	skewY?: BasicShapeSerializedObject["skewY"];
+	cornerRadii?: BasicShapeSerializedObject["cornerRadii"];
+	name?: BasicShapeSerializedObject["name"];
+	shadowOptions?: BasicShapeSerializedObject["shadowOptions"];
+	shadowColor?: NonNullable<BasicShapeSerializedObject["shadowOptions"]>["color"];
+	fill?: BasicShapeSerializedObject["fill"];
+	fillColor?: NonNullable<BasicShapeSerializedObject["fill"]>[number]["value"];
+	stroke?: BasicShapeSerializedObject["stroke"];
+	strokeWidth?: BasicShapeSerializedObject["strokeWidth"];
+};
+export type BasicShapeSerializedObject = typeof BASIC_SHAPE_DEFAULT_VALUES & {
+	nPoints?: number | undefined;
+};
+export type BasicShapeType = (typeof BasicShapeType)[keyof typeof BasicShapeType];
+export type BoardRelinkOptions = {
+	relinkBoardAfterPlacement?: boolean;
+};
+export type BoundingBox = {
+	left: number;
+	top: number;
+	width: number;
+	height: number;
+};
+export type BoundingRect = {
+	top: number;
+	left: number;
+	bottom: number;
+	right: number;
+};
+export type BridgedSdkResult<T> = T extends SdkResult<infer _R, infer _E> ? T : SdkResult<T, Error>;
+export type Builtin = Date | ((...args: never[]) => unknown) | Uint8Array | RegExp | Map<unknown, unknown> | Set<unknown>;
+export type BypassExportDialog = (options: GetExportOptions) => Promise<Blob | null>;
+export type CanvasMode = {
+	mode: "crop";
+	targetId: string;
+} | {
+	mode: "erase";
+	targetId: string;
+} | {
+	mode: "erase-and-fill";
+	targetId: string;
+} | {
+	mode: "reframe";
+	targetId: string;
+} | {
+	mode: "inpaint";
+	targetId: string;
+} | {
+	mode: "custom";
+	id: string;
+	state: JSONObject;
+} | null;
+export type CanvasModeKind = "erase" | "erase-and-fill" | "crop" | "reframe" | "inpaint" | null;
+export type CharacterIndex = number;
+export type CloneArtboardParams = {
+	boardId: string;
+	position: CreateElementWithPositionAndSize["position"];
+};
+export type Color = GradientObject | string | null | undefined;
+export type ColorInfo = StringColor | FullColor;
+export type CombinedShapeSerializedObject = Omit<typeof DEFAULT_VALUES, "shapes"> & {
+	shapes: Shape[];
+};
+export type ConnectBoardsParams = {
+	inputBoardId: string;
+	targetBoardId: string;
+};
+export type ConnectedArtboardOptions<T extends ArtboardLikeType = ArtboardLikeType> = BaseStandardArtboardOptions<T> & {
+	inputBoardIds?: string[];
+};
+export type ContextSubscriptionCallback = (context: KittlContext) => void;
+export type ConvertShapeToMaskInput = {
+	id: NormalizedBasicShapeObject["id"];
+};
+export type CreateBasicShapeInput = CreateElementWithPositionAndSize & {
+	objectName: string;
+	objectProperties?: ShapeProperties;
+};
+export type CreateBoardParams = Omit<CreateElementWithPositionAndSize, "size" | "boardId"> & {
+	title?: string;
+	size: {
+		width: number;
+		height: number;
+	};
+};
+export type CreateElementWithPositionAndSize = {
+	boardId?: string;
+	position: AbsolutePosition | RelativePosition;
+	size?: Dimensions & {
+		applyViewportScale?: boolean;
+	};
+};
+export type CreateGroupParams = {
+	structureIds: string[];
+};
+export type CreateGuideInput = {
+	boardId?: string;
+} & OrientationConditional;
+export type CreateShapeInput = CreateElementWithPositionAndSize & {
+	shapeType: BasicShapeType;
+	objectProperties?: ShapeProperties;
+};
+export type CubicBezierEasing = {
+	type: "cubic-bezier";
+	controlPoints: readonly [
+		x1: number,
+		y1: number,
+		x2: number,
+		y2: number
+	];
+};
+export type CustomCanvasModeId<Id extends string> = Id extends Exclude<CanvasModeKind, null> ? never : Id;
+export type CustomCanvasModeState<Id extends string> = Id extends keyof CustomCanvasModeStateById ? CustomCanvasModeStateById[Id] extends JSONObject ? CustomCanvasModeStateById[Id] : never : JSONObject;
+export type DeepPartial<T> = {
+	[P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+export type DeepValue<T, P extends string> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? DeepValue<NonNullable<T[K]>, Rest> : T extends Record<string, infer V> ? DeepValue<NonNullable<V>, Rest> : undefined : P extends keyof T ? T[P] : T extends Record<string, infer V> ? V : undefined;
+export type DesignApiOptions = APIOptions<NormalizedDesignState>;
+export type DesignObjectId = string;
+export type DesignStateSelectorPath = DesignStateTopLevelKey | `${DesignStateTopLevelKey}.${string}`;
+export type DesignStateTopLevelKey = keyof NormalizedDesignState;
+export type DesignStructureObject = {
+	id?: StructureObjectId | null;
+	meta?: StructureObjectMeta;
+	parentId?: ID;
+};
+export type Dimensions = {
+	width: number;
+	height: number;
+};
+export type DisconnectBoardsParams = ConnectBoardsParams;
+export type EasingName = "linear" | "ease" | "ease-in" | "ease-out" | "ease-in-out";
+export type EditorColorScheme = "light" | "dark";
+export type ElementLocation = "origin" | "center";
+export type Expand<T> = T extends infer O ? {
+	[K in keyof O]: O[K];
+} : never;
+export type ExportAPI = PublicExportAPI;
+export type ExportFieldValue = string | number | boolean | string[];
+export type ExportFieldValues = Record<string, ExportFieldValue>;
+export type ExportMimeType = (typeof EXPORT_MIME_TYPES)[keyof typeof EXPORT_MIME_TYPES];
+export type ExportRequest<Mime extends ExportMimeType = ExportMimeType> = {
+	target: readonly string[];
+	title: string;
+	exportLabel: string;
+	customFields?: readonly PlainInputSetting[];
+	mimeTypes?: readonly Mime[];
+	initialFileFormat?: Mime;
+};
+export type ExportResult = {
+	blobs: readonly Blob[];
+	settings: ExportFieldValues;
+};
+export type FileBrowserContent = FileBrowserItem | FileBrowserFolder;
+export type FileBrowserFetchContentParams = {
+	id?: string;
+	next?: string | number;
+	formats?: readonly FileBrowserMediaFormat[];
+};
+export type FileBrowserFetchContentResult = {
+	content: FileBrowserContent[];
+	next?: string | number;
+	error?: string;
+};
+export type FileBrowserFolder = {
+	type: "folder";
+	label: string;
+	id: string;
+	preview?: string;
+	content?: Array<FileBrowserContent>;
+};
+export type FileBrowserItem = {
+	type: "item";
+	label: string;
+	id: string;
+	preview?: string;
+	animatedPreview?: string;
+	content: {
+		data: string;
+		mimeType?: string;
+		uploadType?: UploadType;
+	};
+};
+export type FileBrowserMediaFormat = "image" | "video";
+export type FileBrowserTab = {
+	id: string;
+	label: string;
+	order?: number;
+	emptyState?: FileBrowserTabEmptyState;
+	supportedFormats?: readonly FileBrowserMediaFormat[];
+	fetchContent: (params?: FileBrowserFetchContentParams) => Promise<FileBrowserFetchContentResult>;
+	onEvent?: (event: FileBrowserTabEvent) => void;
+};
+export type FileBrowserTabEmptyState = "aiCreations" | "uploads";
+export type FileBrowserTabEvent = "close" | "open" | "upload";
+export type FlattenUnion<T> = UnionToIntersection<T extends unknown ? Partial<T> : never>;
+export type FontListDto = PaginatedResult<FontFamilyDto>;
+export type FontVariationSettings = Record<string, number> & Partial<Record<KnownFontVariationAxis, number>>;
+export type FontWeight = OrAnyString<"Regular" | "Bold" | "Light" | "Medium" | "Black" | "SemiBold" | "Italic" | "ExtraLight" | "Thin" | "ExtraBold" | "LightItalic" | "MediumItalic" | "SemiBoldItalic" | "BlackItalic" | "ExtraBoldItalic" | "ThinItalic" | "ExtraLightItalic" | "BoldItalic">;
+export type FullColor = {
+	key: "fill" | (Exclude<string, StringColorKeysType> & {});
+	value: Color;
+	visible: boolean;
+};
+export type FunctionType = (...args: never) => unknown;
+export type GenerationStatus = (typeof GenerationStatus)[keyof typeof GenerationStatus];
+export type GenerationStatusUpdate = {
+	generationId: string;
+	status: typeof GenerationStatus.CREATED;
+	inputData: undefined;
+	creditUse: undefined;
+	result: undefined;
+} | {
+	generationId: string;
+	status: typeof GenerationStatus.QUEUED;
+	inputData?: GenerationInputData;
+	creditUse?: GenerationCreditUse;
+	result?: StartedGenerationResult;
+} | {
+	generationId: string;
+	status: typeof GenerationStatus.STARTED;
+	inputData: GenerationInputData;
+	creditUse?: GenerationCreditUse;
+	result: StartedGenerationResult;
+} | {
+	generationId: string;
+	status: typeof GenerationStatus.COMPLETE;
+	inputData: GenerationInputData;
+	creditUse?: GenerationCreditUse;
+	result: SuccessGenerationResult;
+} | {
+	generationId: string;
+	status: typeof GenerationStatus.FAILED;
+	inputData: GenerationInputData | undefined;
+	creditUse?: GenerationCreditUse;
+	result: ErrorGenerationResult;
+} | {
+	generationId: string;
+	status: typeof GenerationStatus.CANCELLED;
+	inputData?: GenerationInputData;
+	creditUse?: GenerationCreditUse;
+	result: undefined;
+};
+export type GetColorsParams = {
+	objectId: string;
+};
+export type GetIllustrationPathsParams = {
+	id: string;
+};
+export type GuideSerializedObject = typeof GUIDE_DEFAULT_VALUES & OrientationDir;
+export type ID = string;
+export type IllustrationImageSerializedObject = typeof DEFAULT_VALUES$1 & {
+	backgroundRemoved?: boolean | undefined;
+	objectNameWithBackground?: string;
+	backgroundRestorePathBoundary?: number | undefined;
+	realWidth?: number | undefined;
+	realHeight?: number | undefined;
+	erasePaths?: {
+		cacheKey: string;
+		objectName: string | null;
+		fallbackObjectName?: string;
+	} | undefined;
+	eraseStrokeWidth?: number | undefined;
+	inpaintingStrokeWidth?: number | undefined;
+	inpaintingSelectionMode?: InpaintingSelectionMode;
+	eraseAndFillStrokeWidth?: number | undefined;
+	unsplashId?: string | undefined;
+};
+export type IllustrationProperties = {
+	angle?: IllustrationSerializedObject["angle"];
+	defaultName?: IllustrationSerializedObject["defaultName"];
+	flipX?: IllustrationSerializedObject["flipX"];
+	flipY?: IllustrationSerializedObject["flipY"];
+	hidden?: IllustrationSerializedObject["hidden"];
+	opacity?: IllustrationSerializedObject["opacity"];
+	shadowOptions?: IllustrationSerializedObject["shadowOptions"];
+	stroke?: IllustrationSerializedObject["stroke"];
+	strokeWidth?: IllustrationSerializedObject["strokeWidth"];
+	fill?: IllustrationSerializedObject["fill"];
+	gradients?: IllustrationSerializedObject["gradients"];
+	generation?: IllustrationSerializedObject["generation"];
+};
+export type IllustrationSerializedChild = {
+	id: string;
+	isChild: true;
+	baseFill?: string | GradientObject | null;
+	baseStroke?: string | GradientObject | null;
+	name?: string | null;
+	defaultName: string;
+	width: number;
+	height: number;
+	fillRule?: CanvasFillRule;
+	strokeLineCap?: CanvasLineCap;
+	strokeLineJoin?: CanvasLineJoin;
+	strokeWidth?: number;
+	strokeUniform?: boolean;
+	strokeDashArray?: number[];
+	strokeDashOffset?: number;
+	strokeMiterLimit?: number;
+	transform: number[];
+	type: string;
+	opacity: number;
+	locked: boolean;
+	hidden: boolean;
+	path: (string | number)[][];
+	pathOffset?: {
+		x: number;
+		y: number;
+	};
+};
+export type IllustrationSerializedChildren = IllustrationSerializedChild[];
+export type IllustrationSerializedObject = typeof ILLUSTRATION_DEFAULT_VALUES;
+export type ImageCrop = {
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+};
+export type ImageProperties = {
+	angle?: IllustrationImageSerializedObject["angle"];
+	flipX?: IllustrationImageSerializedObject["flipX"];
+	flipY?: IllustrationImageSerializedObject["flipY"];
+	hidden?: IllustrationImageSerializedObject["hidden"];
+	opacity?: IllustrationImageSerializedObject["opacity"];
+	shadowOptions?: IllustrationImageSerializedObject["shadowOptions"];
+	stroke?: IllustrationImageSerializedObject["stroke"];
+	strokeWidth?: IllustrationImageSerializedObject["strokeWidth"];
+	fill?: IllustrationImageSerializedObject["fill"];
+	defaultName?: IllustrationImageSerializedObject["defaultName"];
+	unsplashId?: IllustrationImageSerializedObject["unsplashId"];
+};
+export type ImplementSubStateOptions = DesignApiOptions & {
+	placement?: ImplementSubStatePlacement;
+};
+export type ImplementSubStatePlacement = {
+	afterExistingStandardBoards: {
+		gap?: number;
+		top?: number;
+	};
+} | {
+	absolute: {
+		left: number;
+		top?: number;
+		gap?: number;
+	};
+};
+export type InternalPatchArgs<T> = {
+	patch: PatchTree<T> | PatchTree<T>[];
+	origin: Origin;
+	historyOrigin?: HistoryOrigins;
+};
+export type JSONObject = {
+	[key: string]: JSONValue;
+};
+export type JSONValue = null | boolean | number | string | Array<JSONValue> | JSONObject;
+export type KnownFontVariationAxis = "wght" | "wdth" | "slnt" | "ital" | "opsz" | "GRAD";
+export type LayerIconType = "drawIcon";
+export type LayerType = Exclude<SerializableObjectType, ObjectType.Guide> | typeof structuralGroupType | typeof clippingMaskType | typeof backgroundType | typeof pathType;
+export type LayersMovePosition = "before" | "after" | "into";
+export type LeftTopPosition = {
+	left: number;
+	top: number;
+};
+export type LineHeight = {
+	value: number;
+	unit: LineHeightUnit;
+};
+export type LineHeightUnit = "px" | "%";
+export type LineIndex = number;
+export type LoadingCardSerializedObject = typeof LOADING_CARD_DEFAULT_VALUES & {
+	imageGenerationId?: string | undefined;
+	startedAt?: number | undefined;
+	generatingModelKey?: string | undefined;
+	generationAverageSpeed?: number | undefined;
+};
+export type MaskSerializedObject = typeof MASK_DEFAULT_VALUES & {
+	maskFill?: string | null | undefined;
+	isClipPath?: boolean | undefined;
+};
+export type MockupBoardOptions = ConnectedArtboardOptions<ObjectType.MockupBoard> & {
+	mockupTemplateId?: number;
+	shouldMockupColorMatchArtboard?: boolean;
+};
+export type MockupDesignRect = {
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+};
+export type MockupDesignSerializedObject = typeof MOCKUP_DESIGN_DEFAULT_VALUES & {
+	inputBoardId: string;
+	mockupTemplateId: number;
+	initialNormalizedUnwarpedRect: MockupDesignRect;
+};
+export type MoveToParams = {
+	boardOrObjectIds: string[];
+	position: LayersMovePosition;
+	targetId: string;
+};
+export type NormalizeArray<T> = T extends (infer U)[] ? Record<string, Normalized<U>> : never;
+export type NormalizeObject<T> = Expand<{
+	[K in keyof T]: NormalizeValue<T[K]>;
+} & {
+	[K in keyof T as undefined extends T[K] ? never : NonNullable<T[K]> extends Array<unknown> ? T[K] extends null ? never : `${Extract<K, string>}Indices` : never]: Record<string, string>;
+} & {
+	[K in keyof T as undefined extends T[K] ? NonNullable<T[K]> extends Array<unknown> ? T[K] extends null | undefined ? never : `${Extract<K, string>}Indices` : never : never]?: Record<string, string>;
+}>;
+export type NormalizeValue<T> = T extends null | undefined ? T : NonNullable<T> extends unknown[] | readonly unknown[] ? undefined extends T ? NormalizeArray<NonNullable<T>> | undefined : NormalizeArray<T> : T extends Builtin ? T : NonNullable<T> extends object ? Normalized<T> : T;
+export type Normalized<T> = T extends null | undefined ? T : T extends Builtin ? T : T extends unknown[] | readonly unknown[] ? NormalizeArray<T> : T extends object ? NormalizeObject<T> : T;
+export type NormalizedBasicShapeObject = Normalized<BasicShapeSerializedObject>;
+export type NormalizedBoard = NormalizedStandardBoard | NormalizedFloatingBoard;
+export type NormalizedCombinedShapeObject = Normalized<CombinedShapeSerializedObject>;
+export type NormalizedDesignState = {
+	boards: Record<ID, NormalizedBoard>;
+	boardsIndices: Record<ID, string>;
+	objects: Record<ID, NormalizedObject>;
+	groupStructures: Record<ID, DesignStructureObject>;
+	groupStructuresIndices: Record<ID, string>;
+	config: DesignConfig;
+};
+export type NormalizedFloatingBoard = Normalized<BaseFloatingBoard>;
+export type NormalizedGuideObject = Normalized<GuideSerializedObject>;
+export type NormalizedIllustrationImageObject = Normalized<IllustrationImageSerializedObject>;
+export type NormalizedIllustrationObject = Normalized<IllustrationSerializedObject>;
+export type NormalizedLoadingCardObject = Normalized<LoadingCardSerializedObject>;
+export type NormalizedMaskObject = Normalized<MaskSerializedObject>;
+export type NormalizedMockupDesignObject = Normalized<MockupDesignSerializedObject>;
+export type NormalizedObject = NormalizedStandardObject | NormalizedGuideObject;
+export type NormalizedPathTextObject = Normalized<PathTextSerializedObject>;
+export type NormalizedRichTextObject = Normalized<RichTextSerializedObject>;
+export type NormalizedStandardBoard<T extends ArtboardOptions = ArtboardOptions> = Normalized<BaseStandardBoard<T>>;
+export type NormalizedStandardObject = NormalizedBasicShapeObject | NormalizedCombinedShapeObject | NormalizedIllustrationImageObject | NormalizedIllustrationObject | NormalizedLoadingCardObject | NormalizedMaskObject | NormalizedMockupDesignObject | NormalizedPathTextObject | NormalizedRichTextObject | NormalizedVideoObject;
+export type NormalizedVideoObject = Normalized<VideoSerializedObject>;
+export type NullablePathTextShadowOptions = PathTextShadowOptions | {
+	type: null;
+};
+export type ObjectPosition = {
+	top: number;
+	left: number;
+};
+export type ObjectPositionRect = {
+	width: number;
+	height: number;
+} & ObjectPosition;
+export type OnGenerationStatusUpdate = (update: GenerationStatusUpdate) => void | Promise<void>;
+export type OrAnyString<T extends string> = T | (string & {});
+export type OrientationConditional = {
+	orientation: Orientation.HORIZONTAL;
+	top: number;
+} | {
+	orientation: Orientation.VERTICAL;
+	left: number;
+};
+export type OrientationDir = {
+	orientation: Orientation.HORIZONTAL;
+	top: number;
+} | {
+	orientation: Orientation.VERTICAL;
+	left: number;
+};
+export type OriginX = "left" | "center" | "right";
+export type OriginY = "top" | "center" | "bottom";
+export type PatchAction<T> = {
+	action: Action.MERGE;
+	value: DeepPartial<T>;
+} | {
+	action: Action.SET;
+	value: T;
+} | {
+	action: Action.DELETE;
+};
+export type PatchTree<S> = {
+	[K in keyof S]?: NonNullable<S[K]> extends object ? PatchAction<DeepPartial<S[K]>> | PatchTree<NonNullable<DeepPartial<S[K]>>> : PatchAction<DeepPartial<S[K]>>;
+};
+export type PathTextSerializedObject = typeof PATH_TEXT_DEFAULT_VALUES & {
+	relativeSize?: number | undefined;
+	overrideText?: string | undefined;
+	transformOptions: PathTextTransformOptions;
+	fontFamily?: string | undefined;
+	fontWeight?: string | undefined;
+	text: string;
+	shadowOptions: NullablePathTextShadowOptions;
+	adjustableWidth?: number | undefined;
+	uppercase?: boolean | undefined;
+	underline?: boolean | undefined;
+	variation?: Record<string, number> | undefined;
+	variationAxes?: Record<string, FontVariation> | undefined;
+	decorationOptions?: DecorationOptions | undefined;
+	isUserFont?: boolean | undefined;
+};
+export type PathTextShadowOptions = ShadingOptions & ShadowOptions & {
+	color: string;
+};
+export type PathTextTransformOptions = TransformOptions & {
+	points: {
+		x: number;
+		y: number;
+	}[];
+};
+export type PendingOperation = (typeof PendingOperation)[keyof typeof PendingOperation];
+export type PlainInputSetting = {
+	isPremium?: boolean;
+	name: "combineBoards" | (string & {});
+	label?: string;
+	disabled?: true;
+} & ({
+	type: "selection";
+	options: readonly SelectionOption[];
+	default?: string;
+} | {
+	type: "input";
+	propType: "string";
+	unit?: string;
+	default?: string;
+} | {
+	type: "input";
+	propType: "number";
+	unit?: string;
+	default?: number;
+	max?: number;
+	min?: number;
+} | {
+	type: "input";
+	propType: "boolean";
+	unit?: string;
+	default?: boolean;
+});
+export type PrintMargins = {
+	enabled: boolean;
+	top: number;
+	right: number;
+	bottom: number;
+	left: number;
+};
+export type RelativePosition = {
+	relative: RelativeToObject | RelativeToViewport | RelativeToScreen;
+};
+export type RelativeToObject = {
+	to: Exclude<string, "viewport">;
+	location: ElementLocation;
+	offset?: LeftTopPosition;
+};
+export type RelativeToScreen = {
+	to: "screen";
+	coordinates: ScreenCoordinates;
+	offset?: LeftTopPosition;
+};
+export type RelativeToViewport = {
+	to: "viewport";
+	location: ElementLocation;
+	offset?: LeftTopPosition;
+};
+export type ReleaseTextureParams = {
+	boardId: string;
+};
+export type RemoveFromGroupParams = {
+	objectIds: string[];
+};
+export type RemoveGroupParams = {
+	groupId: string;
+};
+export type RemoveIllustrationPathParams = {
+	illustrationId: string;
+	pathIds: string[];
+};
+export type RemovePlaylistItemParams = {
+	videoBoardId: string;
+	playlistItemId: string;
+};
+export type RemoveTextureParams = {
+	boardId: string;
+};
+export type RemoveVideoPlaylistItemParams = {
+	videoId: string;
+	playlistItemId: string;
+};
+export type RenameIllustrationPathParams = {
+	illustrationId: string;
+	pathId: string;
+	newName: string;
+};
+export type RenameParams = {
+	objectId: string;
+	newName: string;
+};
+export type ReorderVideoPlaylistItemParams = {
+	videoId: string;
+	playlistItemId: string;
+	previousPlaylistItemId?: string;
+	nextPlaylistItemId?: string;
+};
+export type ResetImageBackgroundRemovalParams = {
+	id: IllustrationImageSerializedObject["id"];
+};
+export type ResetImageCropParams = {
+	id: IllustrationImageSerializedObject["id"];
+};
+export type ResultType = (typeof ResultType)[keyof typeof ResultType];
+export type RichTextBasePluginSerializedObject = {
+	id: string;
+	name: string;
+	version: string;
+};
+export type RichTextCompressedColor = string | GradientObject | null;
+export type RichTextCompressedStyles = RichTextCompressedStylesV1 | RichTextCompressedStylesV2;
+export type RichTextDecorationPluginSerializedObject = RichTextBasePluginSerializedObject & {
+	fillStyle: string;
+	[key: string]: string | number;
+};
+export type RichTextHyperlinkSerializedObject = {
+	id: string;
+	url: string;
+};
+export type RichTextRenderPluginSerializedObject = RichTextBasePluginSerializedObject & {
+	color: string;
+	angle: number;
+	offset: number;
+	[key: string]: string | number;
+};
+export type RichTextResizeBehavior = "hug" | "none" | "hug-height" | "fixed-box-fit";
+export type RichTextSerializedCharacterStyle = Partial<{
+	fontFamily: string;
+	fontWeight: FontWeight;
+	fontSize: number;
+	fill: RichTextCompressedColor;
+	underline: boolean;
+	linethrough: boolean;
+	charSpacing: number;
+	textCase: TextCase;
+	lineHeightValue: LineHeight;
+	hyperlinkId: string | null;
+	preLinkFill: RichTextCompressedColor;
+	fontVariationSettings: FontVariationSettings;
+	fontFeatureSettings: Record<string, boolean | number>;
+}>;
+export type RichTextSerializedObject = typeof RICH_TEXT_DEFAULT_VALUES & {
+	text: string;
+	fontFamily: string;
+	styles?: RichTextCompressedStyles;
+	activeRenderPlugins?: RichTextRenderPluginSerializedObject[];
+	activeDecorationPlugins?: RichTextDecorationPluginSerializedObject[];
+	activeTransformPlugin?: RichTextSerializedTransformPluginObject;
+	fontSize?: number;
+	fontWeight?: FontWeight;
+	textAlign?: TextAlign;
+	charSpacing?: number;
+	underline?: boolean;
+	linethrough?: boolean;
+	fontVariationSettings?: FontVariationSettings;
+	textCase?: TextCase;
+	lineHeightValue?: LineHeight;
+	untransformedWidth?: number;
+	widthBeforeTransform?: number;
+	resizeBehavior?: RichTextResizeBehavior;
+	hyperlinkId?: string;
+	preLinkFill?: string | GradientObject | null;
+	fontFeatureSettings?: Record<string, boolean | number>;
+	links?: RichTextHyperlinkSerializedObject[];
+	volatileData?: {
+		top: number;
+		left: number;
+		width: number;
+		height: number;
+		activeTransformPlugin: RichTextSerializedTransformPluginObject;
+		key: string;
+	};
+};
+export type RichTextSerializedTransformPluginObject = RichTextBasePluginSerializedObject & {
+	type?: string;
+	points: {
+		x: number;
+		y: number;
+	}[];
+	curveHeight?: number;
+	directionInverted?: boolean;
+};
+export type SDKColor = string | SDKGradient;
+export type SDKColorEntry = {
+	key: string;
+	color: SDKColor | null;
+};
+export type SDKColorStop = {
+	offset: number;
+	color: string | null;
+};
+export type SDKGradient = SDKLinearGradient | SDKRadialGradient;
+export type SDKLinearGradient = {
+	type: GradientType.Linear;
+	colorStops: SDKColorStop[];
+	angle: number;
+	coords: SDKLinearGradientCoords;
+};
+export type SDKLinearGradientCoords = {
+	x1: number;
+	y1: number;
+	x2: number;
+	y2: number;
+};
+export type SDKRadialGradient = {
+	type: GradientType.Radial;
+	colorStops: SDKColorStop[];
+	angle: number;
+	coords: SDKRadialGradientCoords;
+};
+export type SDKRadialGradientCoords = SDKLinearGradientCoords & {
+	r2: number;
+};
+export type ScreenCoordinates = {
+	x: number;
+	y: number;
+};
+export type SdkError = SdkBadInputError | SdkInternalError;
+export type SdkResponse<T> = {
+	isOk: true;
+	result: T;
+} | {
+	isOk: false;
+	error: Error;
+};
+export type SdkResult<T, E = SdkError> = {
+	isOk: true;
+	result: T;
+	error?: never;
+} | {
+	isOk: false;
+	result?: never;
+	error: E;
+};
+export type SdkResultAsync<T, E = SdkError> = Promise<{
+	isOk: true;
+	result: T;
+	error?: never;
+} | {
+	isOk: false;
+	result?: never;
+	error: E;
+}>;
+export type SelectionOption = {
+	value: string;
+	label: string;
+	disabled?: true;
+	isPremium?: true;
+};
+export type Selector<T, U = unknown> = (state: T) => U;
+export type SelectorState = Omit<NormalizedDesignState, "objects"> & {
+	objects: Record<string, FlattenUnion<NormalizedObject>>;
+};
+export type SendToParams = {
+	boardOrObjectIds: string[];
+};
+export type SequenceLength = number;
+export type SerialisedPhotoFilter = ({
+	type: ImageFilterType;
+} & PhotoFilterOptions[ImageFilterType]) | {
+	type: ImageFilterType;
+};
+export type SerializableCornerRadii = Record<string, Record<string, number>>;
+export type SerializableObjectType = ObjectType.IllustrationImage | ObjectType.Illustration | ObjectType.Artboard | ObjectType.Smartboard | ObjectType.Videoboard | ObjectType.MockupBoard | ObjectType.PathText | ObjectType.RichText | ObjectType.MockupDesign | ObjectType.OverlayTexture | ObjectType.Mask | ObjectType.BasicShape | ObjectType.VectorPath | ObjectType.Guide | ObjectType.CombinedShape | ObjectType.LoadingCard | ObjectType.Video;
+export type SerializedObject = StandardSerializedObject | GuideSerializedObject;
+export type SetCanvasModeWithTargetOptions = {
+	origin?: Origin;
+	targetId?: string | null;
+};
+export type SetColorsParams = {
+	objectId: string;
+	colorEntries: SDKColorEntry[];
+};
+export type SetCustomCanvasModeParams<Id extends string> = {
+	id: CustomCanvasModeId<Id>;
+	state: CustomCanvasModeState<Id>;
+};
+export type SetTextureParams = {
+	boardId: string;
+	texture: string;
+	options?: Partial<TextureOptions>;
+};
+export type SetVideoOnVideoboardParams = {
+	videoBoardId: string;
+	video: {
+		width?: number;
+		height?: number;
+		playlist: VideoPlaylistItemInput[];
+	};
+} & Pick<VideoboardOptions, "generationSettings">;
+export type SettingsType = {
+	gridSize: number;
+	showGrid: boolean;
+	showRuler: boolean;
+	showPrintMargins: boolean;
+	enableGuideRedraw: boolean;
+};
+export type ShadingOptions = AvailableShadowOptions & {
+	type: "drop" | "line" | "block" | "detail";
+	outlineWidth?: number;
+	borderColor?: string | null;
+};
+export type Shape = {
+	groupId?: string;
+} & (BasicShapeSerializedObject | CombinedShapeSerializedObject | IllustrationSerializedObject | PathTextSerializedObject | RichTextSerializedObject);
+export type ShapeBooleanOperation = "unite" | "subtract" | "intersect" | "exclude" | "divide";
+export type ShapeProperties = {
+	angle?: BasicShapeSerializedObject["angle"];
+	flipX?: BasicShapeSerializedObject["flipX"];
+	flipY?: BasicShapeSerializedObject["flipY"];
+	hidden?: BasicShapeSerializedObject["hidden"];
+	opacity?: BasicShapeSerializedObject["opacity"];
+	skewX?: BasicShapeSerializedObject["skewX"];
+	skewY?: BasicShapeSerializedObject["skewY"];
+	cornerRadii?: BasicShapeSerializedObject["cornerRadii"];
+	name?: BasicShapeSerializedObject["name"];
+	shadowOptions?: BasicShapeSerializedObject["shadowOptions"];
+	fill?: NonNullable<BasicShapeSerializedObject["fill"]>;
+	fillColor?: NonNullable<BasicShapeSerializedObject["fill"]>[number]["value"];
+	stroke?: NonNullable<BasicShapeSerializedObject["stroke"]>;
+	strokeWidth?: NonNullable<BasicShapeSerializedObject["strokeWidth"]>;
+};
+export type SmartPlacementInput = {
+	objects: BoundingBox[];
+	padding?: number;
+	applyViewportScale?: boolean;
+	ignoredIds?: string[];
+	targetBoardId?: string;
+};
+export type SmartPlacementOutput = {
+	insertionBoundingBox: BoundingBox;
+	objectPlacements: BoundingBox[];
+};
+export type SmartboardAction = SmartboardActionWithAiPrompt | SmartboardActionInitial;
+export type SmartboardActionInitial = {
+	type: "noAction";
+	aspectRatio?: SmartboardAspectRatio;
+	modelId?: string;
+};
+export type SmartboardActionWithAiPrompt = {
+	type: "aiPrompt";
+	prompt: string;
+	quality?: SmartboardQuality;
+	aspectRatio?: SmartboardAspectRatio;
+	transparentBackground?: boolean;
+	background?: SmartboardBackground;
+	modelId?: string;
+	averageSpeed?: number;
+	generatedContent?: SmartboardGeneratedContent;
+};
+export type SmartboardAspectRatio = string;
+export type SmartboardBackground = "transparent" | "opaque";
+export type SmartboardGeneratedContent = {
+	id: string;
+	status: "STARTED" | "COMPLETE" | "FAILED";
+	objectName?: string;
+	startedAt?: number;
+};
+export type SmartboardGenerationSettings = Record<string, unknown>;
+export type SmartboardOptions = ConnectedArtboardOptions<ObjectType.Smartboard> & {
+	action?: SmartboardAction;
+} & GeneratableBoard<SmartboardGenerationSettings>;
+export type SmartboardQuality = "auto" | "high" | "medium" | "low";
+export type StandardSerializedObject = BasicShapeSerializedObject | CombinedShapeSerializedObject | IllustrationImageSerializedObject | IllustrationSerializedObject | LoadingCardSerializedObject | MaskSerializedObject | MockupDesignSerializedObject | PathTextSerializedObject | RichTextSerializedObject | VideoSerializedObject;
+export type StartedGenerationResult = VideoGenerationStartedResult | ImageGenerationStartedResult;
+export type StateGradientInfo = {
+	[key: string]: GradientInfo;
+};
+export type StringColor = {
+	key: StringColorKeysType;
+	value: string | null | undefined;
+	visible: boolean;
+};
+export type StringColorKeysType = (typeof stringColorKeys)[number];
+export type StructureObjectId = string;
+export type SubscribeOptions = {
+	skipDedupe?: boolean;
+};
+export type SuccessGenerationResult = VideoGenerationResult | ImageGenerationResult;
+export type TempUserImageUpload = {
+	objectId: string;
+	mimeType: string;
+};
+export type TextAlign = "left" | "center" | "right" | "justify" | "justify-left" | "justify-center" | "justify-right" | "justify-legacy";
+export type TextCase = "none" | "uppercase";
+export type TextProperties = {
+	fontFamily?: string;
+	fontSize?: number;
+	fontWeight?: string;
+	fontVariationSettings?: FontVariationSettings;
+	fill?: Color;
+	textAlign?: TextAlign;
+	lineHeightValue?: LineHeight;
+	resizeBehavior?: RichTextResizeBehavior;
+	charSpacing?: number;
+	underline?: boolean;
+	overline?: boolean;
+	linethrough?: boolean;
+	angle?: number;
+	scaleX?: number;
+	scaleY?: number;
+	stroke?: string | null;
+	strokeWidth?: number;
+};
+export type ToggleHideIllustrationPathParams = {
+	illustrationId: string;
+	pathId: string;
+	hidden: boolean;
+};
+export type ToggleLockIllustrationPathParams = {
+	illustrationId: string;
+	pathId: string;
+	locked: boolean;
+};
+export type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type UpdateArtboardBackgroundParams = {
+	id: string;
+	objectName: string;
+};
+export type UpdateArtboardParams = {
+	id: string;
+	artboard?: Partial<ArtboardOptions>;
+	title?: string;
+	texture?: TextureOptions;
+	backgroundImage?: BackgroundImageOptions;
+};
+export type UpdateDecorationPluginParams = {
+	textId: string;
+	decorationPluginId: string;
+	decorationPlugin: Partial<Omit<RichTextDecorationPluginSerializedObject, "id">>;
+};
+export type UpdateIllustrationParams = {
+	id: string;
+	left?: number;
+	top?: number;
+	width?: number;
+	height?: number;
+	objectName?: string;
+	shadowOptions?: IllustrationSerializedObject["shadowOptions"];
+	shadowColor?: NonNullable<IllustrationSerializedObject["shadowOptions"]>["color"];
+	stroke?: IllustrationSerializedObject["stroke"];
+	strokeWidth?: IllustrationSerializedObject["strokeWidth"];
+	fill?: IllustrationSerializedObject["fill"];
+};
+export type UpdateImageParams = {
+	id: IllustrationImageSerializedObject["id"];
+	left?: IllustrationImageSerializedObject["left"];
+	top?: IllustrationImageSerializedObject["top"];
+	width?: IllustrationImageSerializedObject["width"];
+	height?: IllustrationImageSerializedObject["height"];
+	objectName?: IllustrationImageSerializedObject["objectName"];
+	backgroundRemoved?: IllustrationImageSerializedObject["backgroundRemoved"];
+	objectNameWithBackground?: IllustrationImageSerializedObject["objectNameWithBackground"];
+	shadowOptions?: IllustrationImageSerializedObject["shadowOptions"];
+	shadowColor?: NonNullable<IllustrationImageSerializedObject["shadowOptions"]>["color"];
+	stroke?: IllustrationImageSerializedObject["stroke"];
+	strokeWidth?: IllustrationImageSerializedObject["strokeWidth"];
+	inpaintingStrokeWidth?: IllustrationImageSerializedObject["inpaintingStrokeWidth"];
+	inpaintingSelectionMode?: IllustrationImageSerializedObject["inpaintingSelectionMode"];
+} & GeneratableObject;
+export type UpdateImageSourceParams = {
+	id: IllustrationImageSerializedObject["id"];
+	objectName: IllustrationImageSerializedObject["objectName"];
+	keepObjectDimensions?: boolean;
+	resizeMode?: "preserve-rendered-bounds" | "preserve-min-dimension";
+	flatten?: boolean;
+};
+export type UpdateMockupBoardParams = {
+	mockupBoardId: string;
+	size?: Dimensions;
+	mockupTemplateId?: number;
+	fill?: string;
+	shouldMockupColorMatchArtboard?: boolean;
+};
+export type UpdateObjectApiOptions = (Exclude<DesignApiOptions, undefined> & BoardRelinkOptions) | undefined;
+export type UpdatePlaylistItemParams = {
+	videoBoardId: string;
+	playlistItemId: string;
+	playlistItem: Partial<Omit<VideoPlaylistItemInput, "id">>;
+};
+export type UpdateRenderPluginParams = {
+	textId: string;
+	renderPluginId: string;
+	renderPlugin: Partial<Omit<RichTextRenderPluginSerializedObject, "id">>;
+};
+export type UpdateShapeInput = Partial<CreateElementWithPositionAndSize> & BasicShapeConfigurableFields & {
+	id: NormalizedBasicShapeObject["id"];
+};
+export type UpdateSmartboardBackgroundImageParams = {
+	smartboardId: string;
+} & Partial<Pick<BackgroundImageOptions, "objectName" | "generation" | "opacity" | "filters" | "globalCompositeOperation" | "hidden">>;
+export type UpdateSmartboardParams = {
+	smartboardId: string;
+	size?: Dimensions;
+	backgroundImage?: Partial<BackgroundImageOptions>;
+} & Pick<SmartboardOptions, "generationSettings">;
+export type UpdateTextParams = {
+	textId: string;
+	text?: string;
+	left?: number;
+	top?: number;
+	angle?: number;
+} & Partial<TextProperties>;
+export type UpdateTextureParams = {
+	boardId: string;
+	options: Partial<TextureOptions>;
+};
+export type UpdateVideoParams = {
+	videoId: string;
+	position?: AbsolutePosition | RelativePosition;
+	size?: Dimensions;
+	shadowOptions?: VideoSerializedObject["shadowOptions"];
+	shadowColor?: NonNullable<VideoSerializedObject["shadowOptions"]>["color"];
+	stroke?: VideoSerializedObject["stroke"];
+	strokeWidth?: VideoSerializedObject["strokeWidth"];
+};
+export type UpdateVideoPlaylistItemParams = {
+	videoId: string;
+	playlistItemId: string;
+	playlistItem: Partial<Omit<VideoPlaylistItemInput, "id">>;
+};
+export type UpdateVideoboardParams = {
+	videoBoardId: string;
+	size?: Dimensions;
+} & Pick<VideoboardOptions, "generationSettings">;
+export type UploadType = (typeof UploadType)[keyof typeof UploadType];
+export type UploadedFontFamily = {
+	id: string;
+	name: string;
+	fonts: UploadedFontStyle[];
+	workspaceId?: string;
+	preview?: string;
+	extension?: {
+		id: string;
+		name?: string;
+	};
+};
+export type UploadedFontStyle = {
+	name: string;
+	id: string;
+	style: string | null;
+	objectName: string;
+};
+export type UserImageUpload = {
+	id: string;
+	objectName: string;
+	mimeType: string;
+};
+export type VideoBoardGenerationSettings = Record<string, unknown>;
+export type VideoPlaylistItem = {
+	id: string;
+	objectName?: string;
+	startOffset?: number;
+	endOffset?: number;
+	playbackRate: number;
+	volume: number;
+	meta?: GeneratableObject & {
+		generation?: {
+			isGenerating?: boolean;
+		};
+	};
+};
+export type VideoPlaylistItemInput = Omit<VideoPlaylistItem, "id" | "playbackRate" | "volume"> & {
+	playbackRate?: number;
+	volume?: number;
+};
+export type VideoSerializedObject = typeof DEFAULT_VALUES$2 & {
+	playlist: VideoPlaylistItem[];
+	realWidth?: number;
+	realHeight?: number;
+};
+export type VideoboardOptions = ConnectedArtboardOptions<ObjectType.Videoboard> & {
+	video?: {
+		width: number;
+		height: number;
+		playlist: VideoPlaylistItem[];
+	};
+} & GeneratableBoard<VideoBoardGenerationSettings>;
+export type Viewport = {
+	coords: {
+		tl: {
+			x: number;
+			y: number;
+		};
+		tr: {
+			x: number;
+			y: number;
+		};
+		bl: {
+			x: number;
+			y: number;
+		};
+		br: {
+			x: number;
+			y: number;
+		};
+	};
+	transform: [
+		number,
+		number,
+		number,
+		number,
+		number,
+		number
+	];
+};
+export type ViewportAPI = {
+	get(): Viewport;
+	set(patch: ViewportPatch, origin?: Origin): void;
+	getTransform(): Viewport["transform"];
+	setTransform(transform: Viewport["transform"], origin?: Origin): void;
+	getPixelSize(): {
+		width: number;
+		height: number;
+	};
+	getZoom(): number;
+	setZoom(zoom: number, origin?: Origin): void;
+	zoomToPoint(screenPoint: {
+		x: number;
+		y: number;
+	}, zoom: number, origin?: Origin): void;
+	getCoords(): Viewport["coords"];
+	setCoords(coords: Viewport["coords"], origin?: Origin): void;
+	getPosition(): {
+		x: number;
+		y: number;
+	};
+	setPosition(position: {
+		x: number;
+		y: number;
+	}, origin?: Origin): void;
+	centerOnBounds(bounds: BoundingRect, origin?: Origin): void;
+	panTo(position: {
+		x: number;
+		y: number;
+	}, origin?: Origin): void;
+	animateTo(params: AnimateViewportParams, origin?: Origin): Promise<ViewportAnimationResult>;
+	animateToBounds(params: AnimateViewportToBoundsParams, origin?: Origin): Promise<ViewportAnimationResult>;
+	centerToBounds(params: AnimateViewportToCenterParams, origin?: Origin): Promise<ViewportAnimationResult>;
+	expandToBounds(params: AnimateViewportToBoundsParams, origin?: Origin): Promise<ViewportAnimationResult>;
+};
+export type ViewportAnimationResult = {
+	status: "completed";
+} | {
+	status: "interrupted";
+	reason: "superseded" | "viewport-updated" | "destroyed";
+};
+export type ViewportAnimationSettings = {
+	duration?: number;
+	ease?: ViewportEasing;
+};
+export type ViewportBoundsPadding = number | {
+	left?: number;
+	right?: number;
+	top?: number;
+	bottom?: number;
+};
+export type ViewportEasing = EasingName | CubicBezierEasing;
+export type ViewportPatch = {
+	transform: Viewport["transform"];
+	zoom?: never;
+	position?: never;
+} | {
+	zoom: number;
+	position?: {
+		x: number;
+		y: number;
+	};
+	transform?: never;
+} | {
+	position: {
+		x: number;
+		y: number;
+	};
+	zoom?: never;
+	transform?: never;
+};
+export type WithAsync<T> = {
+	[K in keyof T]: T[K] extends (...args: infer Args) => infer Return ? Return extends Promise<infer U> ? (...args: Args) => Promise<BridgedSdkResult<U>> : (...args: Args) => Promise<BridgedSdkResult<Return>> : T[K] extends object ? T[K] extends FunctionType | Array<unknown> ? T[K] : WithAsync<T[K]> : T[K];
+};
+export type WithOptsRemoved<T> = {
+	[K in keyof T]: T[K] extends (...args: infer Args) => infer Return ? Args extends [
+		infer First,
+		...unknown[]
+	] ? (arg: First) => Return : T[K] : T[K] extends object ? WithOptsRemoved<T[K]> : T[K];
+};
+type SharedFileBrowserKittlSDK = KittlSDKLifecycle & Pick<KittlSDKEditorAPIs, "auth" | "context"> & KittlSDKFileBrowserAPI;
+
+export {
+	SharedFileBrowserKittlSDK as KittlSDK,
+};
+
+export {};