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): () => void;
	abstract internalPatch(args: InternalPatchArgs<T>): void;
	abstract resetWithState(state: T): void;
}
declare const BASIC_SHAPE_DEFAULT_VALUES: {
	defaultIcon: LayerIconType | undefined;
	shadowOptions?: {
		color?: string | undefined | null;
		blur?: number | undefined;
		offset?: number;
		angle?: number;
	};
	presets?: LinkedPreset[] | undefined;
	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;
	};
	presets?: LinkedPreset[] | undefined;
	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;
		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;
	presets?: LinkedPreset[] | 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 GUIDE_DEFAULT_VALUES: {
	id: DesignObjectId;
	version: string;
	type: ObjectType.Guide;
};
declare const GenerationStatus: {
	readonly CREATED: "CREATED";
	readonly STARTED: "STARTED";
	readonly COMPLETE: "COMPLETE";
	readonly FAILED: "FAILED";
};
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;
		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;
	presets?: LinkedPreset[] | 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;
	presets?: LinkedPreset[] | 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 RICH_TEXT_DEFAULT_VALUES: {
	presets?: LinkedPreset[] | undefined;
	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 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 LibraryPresetType {
	FILL = "FILL",
	TRANSFORMATION = "TRANSFORMATION",
	PHOTO_FILTER = "PHOTO_FILTER",
	SHADOW = "SHADOW",
	TEXT = "TEXT",
	TEXT_EFFECT = "TEXT_EFFECT",
	TEXT_DECORATION = "TEXT_DECORATION",
	COLOR_PALETTE = "COLOR_PALETTE"
}
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",
	WarpedImage = "warpedImage",
	ArtboardTitle = "artboardTitle",
	ArtboardTitleIcon = "artboardTitleIcon",
	OverlayTexture = "overlayTexture",
	CustomTextbox = "CustomTextbox",
	ClipPath = "clipPath",
	Path = "path",
	Ruler = "ruler",
	WarpControlRootPoint = "warpControlRootPoint",
	Group = "group",
	Circle = "circle",
	Rect = "rect",
	EditablePolygon = "editablePolygon"
}
declare enum Orientation {
	HORIZONTAL = "horizontal",
	VERTICAL = "vertical"
}
declare enum Origin {
	CRDT = 1,
	CANVAS = 2,
	UI = 4,
	VOLATILE = 8,
	EVENTS_SYNC = 16,
	API = 32
}
declare enum TextAlignment {
	right = "right",
	left = "left",
	center = "center",
	justify = "justify",
	justifyLegacy = "justify-legacy"
}
declare enum Unit {
	px = "px",
	in = "in",
	mm = "mm"
}
declare global {
	interface Window {
		kittl: KittlSDK;
	}
}
export declare const kittl: KittlSDK;
export interface AIGenerationInputSettings {
	prompt: string;
	taskType?: AIGenerationModelTaskType;
	promptStyleId?: number;
	model: {
		id: string;
	};
	additionalParams?: Record<string, unknown>;
	actionOrigin?: AIGenerationActionOrigin;
	type: AIGenerationContentType;
}
export interface AIGenerationOutputSettings {
	id?: string;
	dimensions: {
		width: number;
		height: number;
	};
}
export interface AppStateAPI {
	getSelectedObjectsIds(): string[];
	setSelectedObjectsIds(ids: string[]): void;
	getSelectedLayersIds(): string[];
	setSelectedLayersIds(ids: string[]): void;
	getSelectedArtboardIds(): string[];
	setSelectedArtboardIds(ids: string[]): void;
	getSelectedArtboardsObjectIds(): string[];
	setSelectedArtboardsObjectIds(ids: string[]): void;
	getAllSelectedObjectsIds(): string[];
	setAllSelectedObjectsIds(ids: string[]): void;
	getCanvasMode(): AppState["canvasMode"];
	setCanvasMode(mode: AppState["canvasMode"], origin?: Origin): void;
	getActiveTool(): ActiveTool | null;
	setActiveTool(tool: ActiveTool | null): void;
	viewport: ViewportAPI;
	getHighlightedObjectId(): string | null;
	setHighlightedObjectId(id: string | null): void;
	setMany(fields: Partial<AppState>, origin?: Origin): void;
}
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>;
}
export interface AsyncAppStateAPI extends WithAsync<AppStateAPI> {
}
export interface AsyncAppStateSubscriptionAPI {
	/**
	 * Subscribe to one or more paths in the app state.
	 * Each path is a dot-separated string like `'selectedObjectsIds'`.
	 * The callback receives the current value at each path as positional
	 * arguments whenever any subscribed value changes.
	 * Returns a single unsubscribe function that tears down all subscriptions.
	 *
	 * @example
	 * // Single path
	 * const unsub = await kittl.appStore.subscribe(
	 *   ['selectedObjectsIds'],
	 *   (ids) => console.log('selection changed:', ids)
	 * );
	 *
	 * // Multiple paths
	 * const unsub = await kittl.appStore.subscribe(
	 *   ['selectedObjectsIds', 'activeTool'],
	 *   (ids, tool) => console.log('changed:', ids, tool)
	 * );
	 * unsub();
	 */
	subscribe<T extends readonly AppStateSelectorPath[]>(paths: [
		...T
	], callback: (...values: {
		[K in keyof T]: T[K] extends string ? DeepValue<AppState, T[K]> | undefined : unknown;
	}) => void): Promise<() => void>;
}
export interface AsyncAuthAPI {
	startAuth: (request: AuthStartRequest) => Promise<SdkResult<AuthStartResult>>;
	exchangeCode: (request: AuthExchangeRequest) => Promise<SdkResult<AuthTokenResponse>>;
	getAuthToken: (request: AuthGetTokenRequest) => Promise<SdkResult<AuthTokenResponse | null>>;
	refreshToken: (request: AuthRefreshRequest) => Promise<SdkResult<AuthTokenResponse>>;
	logout: (request: AuthLogoutRequest) => Promise<SdkResult<void>>;
}
export interface AsyncBatchDesignAPI extends AsyncDesignAPI {
	commit: () => Promise<void>;
}
export interface AsyncContextAPI extends WithAsync<ContextAPI> {
}
export interface AsyncDesignAPI extends WithAsync<WithOptsRemoved<DesignAPI>> {
}
export interface AsyncDesignStateAPI {
	/**
	 * Subscribe to one or more paths in the design state.
	 * Each path is a dot-separated string like `'objects.id1.width'`.
	 * The callback receives the current value at each path as positional
	 * arguments whenever any subscribed value changes.
	 * Returns a single unsubscribe function that tears down all subscriptions.
	 *
	 * @example
	 * // Single path
	 * const unsub = await kittl.designStore.subscribe(
	 *   ['objects.id1.width'],
	 *   (width) => console.log('width changed:', width)
	 * );
	 *
	 * // Multiple paths
	 * const unsub = await kittl.designStore.subscribe(
	 *   ['objects.id1.width', 'objects.id1.height'],
	 *   (width, height) => console.log('changed:', width, height)
	 * );
	 * unsub();
	 */
	subscribe<T extends readonly DesignStateSelectorPath[]>(paths: [
		...T
	], callback: (...values: {
		[K in keyof T]: T[K] extends string ? DeepValue<SelectorState, T[K]> | undefined : unknown;
	}) => void): Promise<() => void>;
}
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;
	refresh_token: string;
}
export interface AuthStartRequest {
	provider: string;
	params?: Record<string, string | number | boolean>;
	generatePKCE?: boolean;
}
export interface AuthStartResult {
	code: string;
	code_verifier?: string;
}
/**
 * Token response returned by the token endpoint (code exchange or refresh).
 */
export interface AuthTokenResponse {
	access_token?: string;
	refresh_token?: string;
	expires_in?: number;
	[key: string]: unknown;
}
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;
	presets?: LinkedPreset[];
	printMargins?: PrintMargins;
	scaleX?: number;
	scaleY?: number;
}
export interface BaseStandardBoard<T extends ArtboardOptions = ArtboardOptions> {
	id: string;
	artboard: T;
	title?: string;
	texture?: TextureOptions;
	backgroundImage?: BackgroundImageOptions;
}
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;
}
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 ConfigAPI {
	setConfig(config: Partial<DesignConfig>, opts?: DesignApiOptions): void;
}
export interface ContextAPI {
	get(input?: ContextGetInput): KittlContext;
}
export interface ContextGetInput {
	iframe?: Pick<HTMLIFrameElement, "getBoundingClientRect">;
}
export interface CreateLoadingCardInput extends CreateElementWithPositionAndSize {
	imageGenerationId?: string;
	startedAt?: number;
	generatingModelKey?: string;
	generationAverageSpeed?: number;
	name?: string;
}
export interface DecorationOptions {
	type: "horizontalLines" | "colorCut" | "obliqueLines" | "fadingColorCut";
	color: string | null;
	weight: number;
	distance: number;
	cutDistance: number;
}
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;
}
export interface DesignConfig {
	title?: string;
	dpiVersion?: number;
	designId?: string;
	generationId?: string;
	updatedAt?: string;
	templateId?: number | string;
	folderId?: string;
	dpi?: number;
	unit?: Unit;
	overrideColorPalette?: string[];
	overrideColorKeys?: string[];
	overrideLuminosityRatio?: number;
	previewBoardId?: string;
}
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;
	code?: string;
}
export interface FontAPI {
	createFont: (params: {
		name: string;
		files: Blob[];
		styles: string[];
		extensionId?: string;
		previewImage?: Blob;
	}) => SdkResultAsync<UploadedFontFamily, Error>;
}
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;
		generatorKey: string;
	};
}
export interface GenerationInputData {
	prompt?: string;
	style?: {
		id: number;
	};
	model?: {
		id: string;
	};
}
export interface GenerationMeta {
	generationEndsAt?: number;
	pendingGenerationId: string;
}
export interface GenerationStartedResultCommonProps {
	generationEndsAt?: 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;
		};
	};
	removeArtboardBackground?: boolean;
}
export interface GetObjectParams {
	id: string;
}
export interface GetPreviewImageOptions {
	targetPixelCount: 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 {
	addIllustration(params: AddIllustrationParams, opts?: DesignApiOptions): Promise<NormalizedIllustrationObject>;
	updateIllustration(params: UpdateIllustrationParams, opts?: DesignApiOptions): NormalizedIllustrationObject;
}
export interface ImageAPI {
	addImage(params: AddImageParams, opts?: DesignApiOptions): SdkResultAsync<NormalizedIllustrationImageObject, SdkError>;
	updateImage(params: UpdateImageParams, opts?: DesignApiOptions): NormalizedIllustrationImageObject;
}
export interface ImageGenerationResult {
	type: typeof ResultType.IMAGE;
	objectName: string;
}
export interface ImageGenerationStartedResult extends GenerationStartedResultCommonProps {
	type: typeof ResultType.IMAGE;
}
export interface KittlContext {
	colorScheme: EditorColorScheme;
	dragAndDrop: {
		offset: DragAndDropOffset;
	};
}
export interface KittlSDK {
	loaded: boolean;
	onLoadedCallback: (() => void) | null;
	onReady: (cb: () => void) => void;
	ai: AsyncAIAPI;
	design: AsyncDesignAPI;
	designStore: AsyncDesignStateAPI;
	appStore: AsyncAppStateSubscriptionAPI;
	context: AsyncContextAPI;
	dragAndDrop: PublicDragAndDropAPI;
	state: AsyncAppStateAPI;
	auth: AsyncAuthAPI;
	upload: AsyncUploadAPI;
	stateless: AsyncStatelessAPI;
	font: AsyncFontAPI;
	createBatch: () => Promise<AsyncBatchDesignAPI>;
}
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 LinkedFillPresetMeta {
	key: string;
	target: FillMetaTarget;
	source?: string;
}
export interface LoadingCardAPI {
	createLoadingCard(input: CreateLoadingCardInput, opts?: DesignApiOptions): NormalizedLoadingCardObject;
	updateLoadingCard(input: UpdateLoadingCardInput, opts?: DesignApiOptions): NormalizedLoadingCardObject;
}
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 {
	setLockedState(params: SetLockedParams, opts?: DesignApiOptions): WithLocked;
	removeObject(params: RemoveObjectParams, opts?: DesignApiOptions): RemoveObjectResult;
	setHiddenState(params: SetHiddenParams, opts?: DesignApiOptions): WithHidden;
	rotateObject(params: RotateObjectParams, opts?: DesignApiOptions): WithObjectLayout;
	getAllByFilter<T extends NormalizedObject>(predicate: (object: NormalizedObject) => boolean, opts?: DesignApiOptions): T[];
	rename(input: RenameParams, opts?: DesignApiOptions): string;
	getObject(params: GetObjectParams, opts?: DesignApiOptions): NormalizedObject;
	_dangerouslyUpdate(updateParams: Partial<Omit<SerializedObject, "id">> & {
		id: string;
	}, opts?: DesignApiOptions): {
		id: string;
	};
}
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 PublicDragAndDropAPI {
	startDragImageEvent(input: DragAndDropStartDragImageEventInput): void;
	dropImage(input: DragAndDropDropImageInput): Promise<string | null>;
}
export interface RemoveObjectParams {
	id: string;
}
export interface RemoveObjectResult {
	removedObject: NormalizedObject;
}
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 SdkBadInputError extends Error {
	name: "SdkBadInputError";
	message: string;
	cause?: Error;
}
export interface SdkInternalError extends Error {
	name: "SdkInternalError";
	message: string;
	cause?: Error;
}
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?: DesignApiOptions): NormalizedBasicShapeObject;
	convertShapeToMask(input: ConvertShapeToMaskInput, opts?: DesignApiOptions): DesignStructureObject;
}
export interface SmartboardAPI {
	addSmartboard(params: AddSmartboardParams, opts?: DesignApiOptions): NormalizedStandardBoard<SmartboardOptions>;
	updateSmartboard(params: UpdateSmartboardParams, opts?: DesignApiOptions): 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?: DesignApiOptions): Partial<NormalizedDesignState>;
	getState(): NormalizedDesignState;
}
export interface StructureObjectMeta {
	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?: DesignApiOptions): 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 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: UploadImageAPI;
}
export interface UploadImageAPI {
	upload: ({ blob, extensionId, }: {
		blob: Blob;
		extensionId?: string;
	}) => SdkResultAsync<UserImageUpload[], Error>;
	uploadTemp: ({ blob, }: {
		blob: Blob;
	}) => SdkResultAsync<TempUserImageUpload[], Error>;
}
export interface VideoAPI {
	addVideo(params: AddVideoParams, opts?: DesignApiOptions): Promise<NormalizedVideoObject>;
	updateVideo(params: UpdateVideoParams, opts?: DesignApiOptions): NormalizedVideoObject;
	removePlaylistItem(params: RemoveVideoPlaylistItemParams, opts?: DesignApiOptions): NormalizedVideoObject;
	updatePlaylistItem(params: UpdateVideoPlaylistItemParams, opts?: DesignApiOptions): Promise<NormalizedVideoObject>;
}
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_HUB_GENERATE_IMAGE" | "AI_HUB_REMIX_IMAGE" | "AI_HUB_GENERATE_VIDEO" | "VIDEOBOARD";
export type AIGenerationContentType = "image" | "video";
export type AIGenerationModelTaskType = "IMAGE_TO_IMAGE" | "IMAGE_INPAINT" | "TEXT_TO_IMAGE" | "IMAGE_TO_VIDEO";
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: "pen";
} | {
	type: "pen-vector-editing";
} | {
	type: "comment";
} | {
	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;
} & CreateElementWithPositionAndSize;
export type AddIntoGroupParams = {
	groupId: string;
	objectIds: string[];
};
export type AddMockupBoardParams = {
	inputBoardIds: string[];
	mockupTemplateId: number;
	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: Omit<VideoPlaylistItem, "id">[];
	videoSize?: {
		width: number;
		height: number;
	};
} & CreateElementWithPositionAndSize;
export type AddVideoboardParams = {
	linkedBoardIds?: string[];
	video?: {
		width?: number;
		height?: number;
		playlist: Omit<VideoPlaylistItem, "id">[];
	};
} & {
	position: AbsolutePosition | RelativePosition;
	size: Dimensions;
};
export type AppState = {
	selectedObjectsIds: string[];
	selectedLayersIds: string[];
	selectedArtboardIds: string[];
	selectedArtboardsObjectIds: string[];
	allSelectedObjectsIds: string[];
	canvasMode: CanvasMode | string;
	activeTool: ActiveTool | null;
	viewport: Viewport;
	highlightedObjectId: string | null;
};
/**
 * A dot-separated string path into the app state.
 * The first segment must be a valid top-level key of AppState.
 *
 * @example
 * 'selectedObjectsIds'
 * 'viewport.coords.tl.x'
 * 'activeTool.type'
 */
export type AppStateSelectorPath = AppStateTopLevelKey | `${AppStateTopLevelKey}.${string}`;
/**
 * Top-level keys of AppState that extensions can subscribe to.
 */
export type AppStateTopLevelKey = keyof AppState;
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 BridgedSdkResult<T> = T extends SdkResult<infer _R, infer _E> ? T : SdkResult<T, Error>;
export type Builtin = Date | Function | Uint8Array | RegExp | Map<unknown, unknown> | Set<unknown>;
export type CanvasMode = "erase" | "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 ConnectedArtboardOptions<T extends ArtboardLikeType = ArtboardLikeType> = BaseStandardArtboardOptions<T> & {
	inputBoardIds?: string[];
};
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 DeepPartial<T> = {
	[P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};
/**
 * Resolves a dot-separated string path against a type `T`.
 *
 * For `Record<string, V>` intermediaries (e.g. `objects`), any string
 * key is accepted and the type continues into `V`.
 *
 * @example
 * DeepValue<SelectorState, 'objects.id1.width'> // number | undefined
 * DeepValue<SelectorState, 'config'>            // DesignConfig
 * DeepValue<AppState, 'viewport.coords.tl.x'>  // number
 */
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;
/**
 * A dot-separated string path into the design state.
 * The first segment must be a valid top-level key of NormalizedDesignState.
 *
 * @example
 * 'objects.id1.width'
 * 'config.title'
 * 'boards.board1.backgroundColor'
 */
export type DesignStateSelectorPath = DesignStateTopLevelKey | `${DesignStateTopLevelKey}.${string}`;
/**
 * Top-level keys of NormalizedDesignState that extensions can subscribe to.
 */
export type DesignStateTopLevelKey = keyof NormalizedDesignState;
export type DesignStructureObject = {
	id?: StructureObjectId | null;
	meta?: StructureObjectMeta;
	parentId?: ID;
};
export type Dimensions = {
	width: number;
	height: number;
};
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 FillMetaTarget = "border" | "fill";
export type FlattenUnion<T> = UnionToIntersection<T extends unknown ? Partial<T> : never>;
export type FontVariationAxis = OrAnyString<"wght" | "wdth" | "slnt" | "ital" | "opsz" | "GRAD">;
export type FontVariationSettings = Partial<Record<FontVariationAxis, 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;
	result: undefined;
} | {
	generationId: string;
	status: typeof GenerationStatus.STARTED;
	inputData: GenerationInputData;
	result: StartedGenerationResult;
} | {
	generationId: string;
	status: typeof GenerationStatus.COMPLETE;
	inputData: GenerationInputData;
	result: SuccessGenerationResult;
} | {
	generationId: string;
	status: typeof GenerationStatus.FAILED;
	inputData: GenerationInputData | undefined;
	result: ErrorGenerationResult;
};
export type GuideSerializedObject = typeof GUIDE_DEFAULT_VALUES & OrientationDir;
export type ID = string;
export type IllustrationImageSerializedObject = typeof DEFAULT_VALUES$1 & {
	backgroundRemoved?: boolean | undefined;
	objectNameWithBackground?: string;
	realWidth?: number | undefined;
	realHeight?: number | undefined;
	erasePaths?: {
		cacheKey: string;
		objectName: string | null;
		fallbackObjectName?: string;
	} | undefined;
	_eraseStrokeWidth?: number | undefined;
};
export type IllustrationProperties = {
	angle?: IllustrationSerializedObject["angle"];
	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"];
};
export type IllustrationSerializedObject = typeof ILLUSTRATION_DEFAULT_VALUES;
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"];
};
export type InternalPatchArgs<T> = {
	patch: PatchTree<T> | PatchTree<T>[];
	origin: Origin;
	historyOrigin?: HistoryOrigins;
	transactionMeta?: TransactionMeta;
};
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 LinkedPreset = {
	id: string;
	libraryId: string;
} & LinkedPresetMeta;
export type LinkedPresetMeta = {
	type: LibraryPresetType.FILL;
	meta: LinkedFillPresetMeta;
} | {
	type: LibraryPresetType.TRANSFORMATION;
	meta?: never;
} | {
	type: LibraryPresetType.PHOTO_FILTER;
	meta?: never;
} | {
	type: LibraryPresetType.SHADOW;
	meta?: never;
} | {
	type: LibraryPresetType.TEXT;
	meta?: never;
} | {
	type: LibraryPresetType.TEXT_EFFECT;
	meta?: never;
} | {
	type: LibraryPresetType.TEXT_DECORATION;
	meta?: never;
};
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 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 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 RemovePlaylistItemParams = {
	videoBoardId: string;
	playlistItemId: string;
};
export type RemoveTextureParams = {
	boardId: string;
};
export type RemoveVideoPlaylistItemParams = {
	videoId: string;
	playlistItemId: string;
};
export type RenameParams = {
	objectId: string;
	newName: string;
};
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";
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 ScreenCoordinates = {
	x: number;
	y: number;
};
export type SdkError = SdkBadInputError | SdkInternalError;
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 Selector<T, U = unknown> = (state: T) => U;
/**
 * The design state shape exposed to string path selectors.
 * `objects` values are flattened so that variant-specific properties
 * (e.g. `width`, `fill`) are accessible without manual narrowing.
 */
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 SetTextureParams = {
	boardId: string;
	texture: string;
	options?: Partial<TextureOptions>;
};
export type SetVideoOnVideoboardParams = {
	videoBoardId: string;
	video: {
		width?: number;
		height?: number;
		playlist: Omit<VideoPlaylistItem, "id">[];
	};
} & Pick<VideoboardOptions, "generationSettings">;
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 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 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;
	fill?: Color;
	textAlign?: "left" | "center" | "right" | "justify";
	lineHeightValue?: LineHeight;
	resizeBehavior?: "none" | "hug" | "hug-height";
	charSpacing?: number;
	underline?: boolean;
	overline?: boolean;
	linethrough?: boolean;
	angle?: number;
	scaleX?: number;
	scaleY?: number;
	stroke?: string;
	strokeWidth?: number;
};
export type TransactionMeta = {
	isLocal: boolean;
	isUndoRedo: boolean;
};
/**
 * Collapses a union type into a single object type where:
 * - Properties shared by all members keep their original type.
 * - Properties that exist only on some members become optional.
 */
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"];
	shadowOptions?: IllustrationImageSerializedObject["shadowOptions"];
	shadowColor?: NonNullable<IllustrationImageSerializedObject["shadowOptions"]>["color"];
	stroke?: IllustrationImageSerializedObject["stroke"];
	strokeWidth?: IllustrationImageSerializedObject["strokeWidth"];
} & GeneratableObject;
export type UpdateMockupBoardParams = {
	mockupBoardId: string;
	size?: Dimensions;
	mockupTemplateId?: number;
	shouldMockupColorMatchArtboard?: boolean;
};
export type UpdatePlaylistItemParams = {
	videoBoardId: string;
	playlistItemId: string;
	playlistItem: Omit<VideoPlaylistItem, "id">;
};
export type UpdateRenderPluginParams = {
	textId: string;
	renderPluginId: string;
	renderPlugin: Partial<Omit<RichTextRenderPluginSerializedObject, "id">>;
};
export type UpdateShapeInput = Partial<CreateElementWithPositionAndSize> & BasicShapeConfigurableFields & {
	id: NormalizedBasicShapeObject["id"];
};
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: Omit<VideoPlaylistItem, "id">;
	allowAspectRatioMismatch?: boolean;
};
export type UpdateVideoboardParams = {
	videoBoardId: string;
	size?: Dimensions;
} & Pick<VideoboardOptions, "generationSettings">;
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;
	meta?: GeneratableObject & {
		generation?: {
			isGenerating?: boolean;
		};
	};
};
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;
	getZoom(): number;
	setZoom(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;
};
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];
};

export as namespace kittl;

export {};