Version: 0.0.4

Published SDK 0.0.4 API

This inventory comes from the kittl type in @kittl/[email protected], including inherited and async APIs. It lists the callable API paths and their published signatures; it does not assume that an older release exposes newer APIs.

For all parameter, result, and state fields, see interfaces, type aliases, and supporting declarations. These pages quote the exact npm declarations.

Entrypoints

Import	Published declarations
`@kittl/sdk`	Download

Changes since 0.0.3

Adds context subscriptions and state.getIsDragPanning().

Added API members

kittl.context.subscribe
kittl.state.getIsDragPanning

Removed API members

None.

Changed API signatures

kittl.state.getActiveTool

Added declarations

ContextSubscriptionCallback

Removed declarations

None.

Changed declarations

AppStateAPI
AsyncContextAPI
ContextAPI
ActiveTool
AppState

Changes to declarations can include type refactoring as well as API changes. Compare the published signatures and fields when updating an app.

Callable API members

Long inferred async return types are written as Promise<BridgedSdkResult<Awaited<HostReturn>>> using the published host return alias. BridgedSdkResult preserves an existing SDK result, or wraps an ordinary value in SdkResult. The exact wrapper definitions and all return fields are in the type reference above.

kittl.onLoadedCallback

Member	Signature
`kittl.onLoadedCallback`	`(): void`

kittl.onReady

Member	Signature
`kittl.onReady`	`(cb: () => void): void`

kittl.ai

Member	Signature
`kittl.ai.spendCredits`	`(options: SpendCreditsOptions): SdkResultAsync<SpendCreditsResult, Error>`
`kittl.ai.startGeneration`	`(generatorId: string, inputSettings: AIGenerationInputSettings, output: AIGenerationOutputSettings): SdkResultAsync<StartGenerationResult, Error>`
`kittl.ai.registerHandler`	`(generatorId: string, onStatusUpdate: OnGenerationStatusUpdate): SdkResultAsync<() => void, Error>`

kittl.design.shape

Member	Signature
`kittl.design.shape.createPredefinedShape`	`(arg: CreateShapeInput): Promise<BridgedSdkResult<Awaited<NormalizedBasicShapeObject>>>`
`kittl.design.shape.createBasicShape`	`(arg: CreateBasicShapeInput): Promise<BridgedSdkResult<Awaited<Promise<NormalizedBasicShapeObject>>>>`
`kittl.design.shape.updateShape`	`(arg: UpdateShapeInput): Promise<BridgedSdkResult<Awaited<NormalizedBasicShapeObject>>>`
`kittl.design.shape.convertShapeToMask`	`(arg: ConvertShapeToMaskInput): Promise<SdkResult<DesignStructureObject, Error>>`

kittl.design.board

Member	Signature
`kittl.design.board.createStandardBoard`	`(arg: CreateBoardParams): Promise<BridgedSdkResult<Awaited<NormalizedBoard>>>`
`kittl.design.board.cloneArtboard`	`(arg: CloneArtboardParams): Promise<BridgedSdkResult<Awaited<NormalizedBoard>>>`
`kittl.design.board.updateArtboardBackground`	`(arg: UpdateArtboardBackgroundParams): Promise<BridgedSdkResult<Awaited<NormalizedBoard>>>`
`kittl.design.board.updateArtboard`	`(arg: UpdateArtboardParams): Promise<BridgedSdkResult<Awaited<NormalizedBoard>>>`

kittl.design.config

Member	Signature
`kittl.design.config.setConfig`	`(arg: Partial<DesignConfig>): Promise<SdkResult<void, Error>>`

kittl.design.text

Member	Signature
`kittl.design.text.addText`	`(arg: AddTextParams): Promise<BridgedSdkResult<Awaited<NormalizedRichTextObject>>>`
`kittl.design.text.updateText`	`(arg: UpdateTextParams): Promise<BridgedSdkResult<Awaited<NormalizedRichTextObject>>>`
`kittl.design.text.updateRenderPlugin`	`(arg: UpdateRenderPluginParams): Promise<BridgedSdkResult<Awaited<NormalizedRichTextObject>>>`
`kittl.design.text.updateDecorationPlugin`	`(arg: UpdateDecorationPluginParams): Promise<BridgedSdkResult<Awaited<NormalizedRichTextObject>>>`

kittl.design.object

Member	Signature
`kittl.design.object.setLockedState`	`(arg: SetLockedParams): Promise<SdkResult<WithLocked, Error>>`
`kittl.design.object.removeObject`	`(arg: RemoveObjectParams): Promise<SdkResult<RemoveObjectResult, Error>>`
`kittl.design.object.setHiddenState`	`(arg: SetHiddenParams): Promise<SdkResult<WithHidden, Error>>`
`kittl.design.object.rotateObject`	`(arg: RotateObjectParams): Promise<SdkResult<WithObjectLayout, Error>>`
`kittl.design.object.getAllByFilter`	`(arg: (object: NormalizedObject) => boolean): Promise<SdkResult<NormalizedObject[], Error>>`
`kittl.design.object.rename`	`(arg: RenameParams): Promise<SdkResult<string, Error>>`
`kittl.design.object.getObject`	`(arg: GetObjectParams): Promise<BridgedSdkResult<Awaited<NormalizedObject>>>`
`kittl.design.object._dangerouslyUpdate`	`(arg: Partial<Omit<SerializedObject, "id">> & { id: string; }): Promise<SdkResult<{ id: string; }, Error>>`

kittl.design.guide

Member	Signature
`kittl.design.guide.createGuide`	`(arg: CreateGuideInput): Promise<SdkResult<{ id: DesignObjectId; version: string; type: ObjectType.Guide; orientation: Orientation.HORIZONTAL; top: number; }, Error>> \| Promise<SdkResult<{ id: DesignObjectId; version: string; type: ObjectType.Guide; orientation: Orientation.VERTICAL; left: number; }, Error>>`
`kittl.design.guide.updateGuide`	`(arg: UpdateGuideInput): Promise<SdkResult<{ id: DesignObjectId; version: string; type: ObjectType.Guide; orientation: Orientation.HORIZONTAL; top: number; }, Error>> \| Promise<SdkResult<{ id: DesignObjectId; version: string; type: ObjectType.Guide; orientation: Orientation.VERTICAL; left: number; }, Error>>`

kittl.design.loadingCard

Member	Signature
`kittl.design.loadingCard.createLoadingCard`	`(arg: CreateLoadingCardInput): Promise<BridgedSdkResult<Awaited<NormalizedLoadingCardObject>>>`
`kittl.design.loadingCard.updateLoadingCard`	`(arg: UpdateLoadingCardInput): Promise<BridgedSdkResult<Awaited<NormalizedLoadingCardObject>>>`

kittl.design.image

Member	Signature
`kittl.design.image.addImage`	`(arg: AddImageParams): Promise<BridgedSdkResult<Awaited<SdkResultAsync<NormalizedIllustrationImageObject, SdkError>>>>`
`kittl.design.image.updateImage`	`(arg: UpdateImageParams): Promise<BridgedSdkResult<Awaited<NormalizedIllustrationImageObject>>>`

kittl.design.illustration

Member	Signature
`kittl.design.illustration.addIllustration`	`(arg: AddIllustrationParams): Promise<BridgedSdkResult<Awaited<Promise<NormalizedIllustrationObject>>>>`
`kittl.design.illustration.updateIllustration`	`(arg: UpdateIllustrationParams): Promise<BridgedSdkResult<Awaited<NormalizedIllustrationObject>>>`

kittl.design.state

Member	Signature
`kittl.design.state.implementSubState`	`(arg: Partial<NormalizedDesignState>): Promise<SdkResult<Partial<NormalizedDesignState>, Error>>`
`kittl.design.state.getState`	`(): Promise<SdkResult<NormalizedDesignState, Error>>`

kittl.design.canvas

Member	Signature
`kittl.design.canvas.getScreenshot`	`(): Promise<SdkResult<{ data: string; width: number; height: number; }, Error>>`
`kittl.design.canvas.getPreviewImage`	`(arg: string): Promise<{ isOk: false; result?: never; error: Error; } \| { isOk: true; result: string; error?: never; } \| { isOk: true; result: null; error?: never; }>`
`kittl.design.canvas.getExport`	`(arg: GetExportOptions): Promise<{ isOk: false; result?: never; error: Error; } \| { isOk: true; result: null; error?: never; } \| { isOk: true; result: Blob; error?: never; }>`

kittl.design.mockupboard

Member	Signature
`kittl.design.mockupboard.addMockupBoard`	`(arg: AddMockupBoardParams): Promise<BridgedSdkResult<Awaited<NormalizedStandardBoard<MockupBoardOptions>>>>`
`kittl.design.mockupboard.addMockupDesignObject`	`(arg: AddMockupDesignObjectParams): Promise<SdkResult<{ hidden?: boolean \| undefined \| undefined; locked?: boolean \| undefined \| 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; inputBoardId: string; mockupTemplateId: number; initialNormalizedUnwarpedRect: { x: number; y: number; width: number; height: number; }; }, Error>>`
`kittl.design.mockupboard.updateMockupBoard`	`(arg: UpdateMockupBoardParams): Promise<BridgedSdkResult<Awaited<NormalizedStandardBoard<MockupBoardOptions>>>>`

kittl.design.smartboard

Member	Signature
`kittl.design.smartboard.addSmartboard`	`(arg: AddSmartboardParams): Promise<BridgedSdkResult<Awaited<NormalizedStandardBoard<SmartboardOptions>>>>`
`kittl.design.smartboard.updateSmartboard`	`(arg: UpdateSmartboardParams): Promise<BridgedSdkResult<Awaited<NormalizedStandardBoard<SmartboardOptions>>>>`

kittl.design.video

Member	Signature
`kittl.design.video.addVideo`	`(arg: AddVideoParams): Promise<BridgedSdkResult<Awaited<Promise<NormalizedVideoObject>>>>`
`kittl.design.video.updateVideo`	`(arg: UpdateVideoParams): Promise<BridgedSdkResult<Awaited<NormalizedVideoObject>>>`
`kittl.design.video.removePlaylistItem`	`(arg: RemoveVideoPlaylistItemParams): Promise<BridgedSdkResult<Awaited<NormalizedVideoObject>>>`
`kittl.design.video.updatePlaylistItem`	`(arg: UpdateVideoPlaylistItemParams): Promise<BridgedSdkResult<Awaited<Promise<NormalizedVideoObject>>>>`

kittl.design.videoboard

Member	Signature
`kittl.design.videoboard.addVideoboard`	`(arg: AddVideoboardParams): Promise<BridgedSdkResult<Awaited<Promise<NormalizedStandardBoard<VideoboardOptions>>>>>`
`kittl.design.videoboard.setVideoOnVideoboard`	`(arg: SetVideoOnVideoboardParams): Promise<BridgedSdkResult<Awaited<Promise<NormalizedStandardBoard<VideoboardOptions>>>>>`
`kittl.design.videoboard.updateVideoboard`	`(arg: UpdateVideoboardParams): Promise<BridgedSdkResult<Awaited<NormalizedStandardBoard<VideoboardOptions>>>>`
`kittl.design.videoboard.removePlaylistItem`	`(arg: RemovePlaylistItemParams): Promise<BridgedSdkResult<Awaited<NormalizedStandardBoard<VideoboardOptions>>>>`
`kittl.design.videoboard.updatePlaylistItem`	`(arg: UpdatePlaylistItemParams): Promise<BridgedSdkResult<Awaited<Promise<NormalizedStandardBoard<VideoboardOptions>>>>>`

kittl.design.layers

Member	Signature
`kittl.design.layers.moveTo`	`(arg: MoveToParams): Promise<SdkResult<void, Error>>`
`kittl.design.layers.sendForward`	`(arg: SendToParams): Promise<SdkResult<void, Error>>`
`kittl.design.layers.sendToFront`	`(arg: SendToParams): Promise<SdkResult<void, Error>>`
`kittl.design.layers.sendBackward`	`(arg: SendToParams): Promise<SdkResult<void, Error>>`
`kittl.design.layers.sendToBack`	`(arg: SendToParams): Promise<SdkResult<void, Error>>`

kittl.design.group

Member	Signature
`kittl.design.group.createGroup`	`(arg: CreateGroupParams): Promise<SdkResult<void, Error>>`
`kittl.design.group.removeGroup`	`(arg: RemoveGroupParams): Promise<SdkResult<void, Error>>`
`kittl.design.group.addIntoGroup`	`(arg: AddIntoGroupParams): Promise<SdkResult<void, Error>>`
`kittl.design.group.removeFromGroup`	`(arg: RemoveFromGroupParams): Promise<SdkResult<void, Error>>`

kittl.design.texture

Member	Signature
`kittl.design.texture.setTexture`	`(arg: SetTextureParams): Promise<{ isOk: false; result?: never; error: SdkError; }> \| Promise<{ isOk: true; result: NormalizedBoard; error?: never; }>`
`kittl.design.texture.removeTexture`	`(arg: RemoveTextureParams): Promise<{ isOk: false; result?: never; error: SdkError; }> \| Promise<{ isOk: true; result: NormalizedBoard; error?: never; }>`
`kittl.design.texture.updateTexture`	`(arg: UpdateTextureParams): Promise<{ isOk: false; result?: never; error: SdkError; }> \| Promise<{ isOk: true; result: NormalizedBoard; error?: never; }>`
`kittl.design.texture.releaseTexture`	`(arg: ReleaseTextureParams): Promise<{ isOk: false; result?: never; error: SdkError; }> \| Promise<{ isOk: true; result: IllustrationImageSerializedObject; error?: never; }>`

kittl.designStore

Member	Signature
`kittl.designStore.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>`

kittl.appStore

Member	Signature
`kittl.appStore.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>`

kittl.context

Member	Signature
`kittl.context.subscribe`	`(callback: ContextSubscriptionCallback): Promise<() => void>`
`kittl.context.get`	`(input?: ContextGetInput \| undefined): Promise<SdkResult<KittlContext, Error>>`

kittl.dragAndDrop

Member	Signature
`kittl.dragAndDrop.startDragImageEvent`	`(input: DragAndDropStartDragImageEventInput): void`
`kittl.dragAndDrop.dropImage`	`(input: DragAndDropDropImageInput): Promise<string \| null>`

kittl.state

Member	Signature
`kittl.state.getSelectedObjectsIds`	`(): Promise<SdkResult<string[], Error>>`
`kittl.state.setSelectedObjectsIds`	`(ids: string[]): Promise<SdkResult<void, Error>>`
`kittl.state.getSelectedLayersIds`	`(): Promise<SdkResult<string[], Error>>`
`kittl.state.setSelectedLayersIds`	`(ids: string[]): Promise<SdkResult<void, Error>>`
`kittl.state.getSelectedArtboardIds`	`(): Promise<SdkResult<string[], Error>>`
`kittl.state.setSelectedArtboardIds`	`(ids: string[]): Promise<SdkResult<void, Error>>`
`kittl.state.getSelectedArtboardsObjectIds`	`(): Promise<SdkResult<string[], Error>>`
`kittl.state.setSelectedArtboardsObjectIds`	`(ids: string[]): Promise<SdkResult<void, Error>>`
`kittl.state.getAllSelectedObjectsIds`	`(): Promise<SdkResult<string[], Error>>`
`kittl.state.setAllSelectedObjectsIds`	`(ids: string[]): Promise<SdkResult<void, Error>>`
`kittl.state.getCanvasMode`	`(): Promise<SdkResult<string, Error>> \| Promise<SdkResult<null, Error>>`
`kittl.state.setCanvasMode`	`(mode: string \| null, origin?: Origin \| undefined): Promise<SdkResult<void, Error>>`
`kittl.state.getActiveTool`	`(): Promise<SdkResult<null, Error>> \| Promise<SdkResult<{ type: "artboard"; }, Error>> \| Promise<SdkResult<{ type: "move"; }, Error>> \| Promise<SdkResult<{ type: "hand"; }, Error>> \| Promise<SdkResult<{ type: "pen"; }, Error>> \| Promise<SdkResult<{ type: "pen-vector-editing"; }, Error>> \| Promise<SdkResult<{ type: "comment"; }, Error>> \| Promise<SdkResult<{ type: "shape"; shape: BasicShapeType; }, Error>>`
`kittl.state.setActiveTool`	`(tool: ActiveTool \| null): Promise<SdkResult<void, Error>>`
`kittl.state.getIsDragPanning`	`(): Promise<SdkResult<false, Error>> \| Promise<SdkResult<true, Error>>`
`kittl.state.viewport.get`	`(): Promise<SdkResult<Viewport, Error>>`
`kittl.state.viewport.set`	`(patch: ViewportPatch, origin?: Origin \| undefined): Promise<SdkResult<void, Error>>`
`kittl.state.viewport.getTransform`	`(): Promise<SdkResult<[number, number, number, number, number, number], Error>>`
`kittl.state.viewport.setTransform`	`(transform: [number, number, number, number, number, number], origin?: Origin \| undefined): Promise<SdkResult<void, Error>>`
`kittl.state.viewport.getZoom`	`(): Promise<SdkResult<number, Error>>`
`kittl.state.viewport.setZoom`	`(zoom: number, origin?: Origin \| undefined): Promise<SdkResult<void, Error>>`
`kittl.state.viewport.getCoords`	`(): Promise<SdkResult<{ tl: { x: number; y: number; }; tr: { x: number; y: number; }; bl: { x: number; y: number; }; br: { x: number; y: number; }; }, Error>>`
`kittl.state.viewport.setCoords`	`(coords: { tl: { x: number; y: number; }; tr: { x: number; y: number; }; bl: { x: number; y: number; }; br: { x: number; y: number; }; }, origin?: Origin \| undefined): Promise<SdkResult<void, Error>>`
`kittl.state.viewport.getPosition`	`(): Promise<SdkResult<{ x: number; y: number; }, Error>>`
`kittl.state.viewport.setPosition`	`(position: { x: number; y: number; }, origin?: Origin \| undefined): Promise<SdkResult<void, Error>>`
`kittl.state.getHighlightedObjectId`	`(): Promise<SdkResult<string, Error>> \| Promise<SdkResult<null, Error>>`
`kittl.state.setHighlightedObjectId`	`(id: string \| null): Promise<SdkResult<void, Error>>`
`kittl.state.setMany`	`(fields: Partial<AppState>, origin?: Origin \| undefined): Promise<SdkResult<void, Error>>`

kittl.auth

Member	Signature
`kittl.auth.startAuth`	`(request: AuthStartRequest): Promise<SdkResult<AuthStartResult>>`
`kittl.auth.exchangeCode`	`(request: AuthExchangeRequest): Promise<SdkResult<AuthTokenResponse>>`
`kittl.auth.getAuthToken`	`(request: AuthGetTokenRequest): Promise<SdkResult<AuthTokenResponse \| null>>`
`kittl.auth.refreshToken`	`(request: AuthRefreshRequest): Promise<SdkResult<AuthTokenResponse>>`
`kittl.auth.logout`	`(request: AuthLogoutRequest): Promise<SdkResult<void>>`

kittl.upload

Member	Signature
`kittl.upload.image.upload`	`(args_0: { blob: Blob; extensionId?: string; }): Promise<{ isOk: true; result: UserImageUpload[]; error?: never; } \| { isOk: false; result?: never; error: Error; }>`
`kittl.upload.image.uploadTemp`	`(args_0: { blob: Blob; }): Promise<{ isOk: false; result?: never; error: Error; } \| { isOk: true; result: TempUserImageUpload[]; error?: never; }>`

kittl.stateless

Member	Signature
`kittl.stateless.send`	`(message: { type: string; payload: Record<string, unknown>; }): SdkResultAsync<null>`
`kittl.stateless.subscribe`	`(key: string, handler: (payload: Record<string, unknown>) => void): SdkResultAsync<null>`
`kittl.stateless.unsubscribe`	`(key: string): SdkResultAsync<null>`

kittl.font

Member	Signature
`kittl.font.createFont`	`(params: { name: string; files: Blob[]; styles: string[]; extensionId?: string; previewImage?: Blob; }): Promise<{ isOk: false; result?: never; error: Error; } \| { isOk: true; result: UploadedFontFamily; error?: never; }>`

kittl.createBatch

Member	Signature
`kittl.createBatch`	`(): Promise<AsyncBatchDesignAPI>`

Entrypoints​

Changes since 0.0.3​

Added API members​

Removed API members​

Changed API signatures​

Added declarations​

Removed declarations​

Changed declarations​

Callable API members​

kittl.onLoadedCallback​

kittl.onReady​

kittl.ai​

kittl.design.shape​

kittl.design.board​

kittl.design.config​

kittl.design.text​

kittl.design.object​

kittl.design.guide​

kittl.design.loadingCard​

kittl.design.image​

kittl.design.illustration​

kittl.design.state​

kittl.design.canvas​

kittl.design.mockupboard​

kittl.design.smartboard​

kittl.design.video​

kittl.design.videoboard​

kittl.design.layers​

kittl.design.group​

kittl.design.texture​

kittl.designStore​

kittl.appStore​

kittl.context​

kittl.dragAndDrop​

kittl.state​

kittl.auth​

kittl.upload​

kittl.stateless​

kittl.font​

kittl.createBatch​